@googleapis/discoveryengine 5.0.0 → 6.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +18 -0
- package/build/v1alpha.d.ts +1665 -163
- package/build/v1alpha.js +432 -0
- package/build/v1alpha.js.map +1 -1
- package/build/v1beta.d.ts +2630 -133
- package/build/v1beta.js +1894 -266
- package/build/v1beta.js.map +1 -1
- package/package.json +1 -1
- package/v1alpha.ts +2786 -190
- package/v1beta.ts +9943 -3276
package/build/v1beta.js
CHANGED
|
@@ -165,6 +165,8 @@ var discoveryengine_v1beta;
|
|
|
165
165
|
new Resource$Projects$Locations$Collections$Datastores$Servingconfigs(this.context);
|
|
166
166
|
this.siteSearchEngine =
|
|
167
167
|
new Resource$Projects$Locations$Collections$Datastores$Sitesearchengine(this.context);
|
|
168
|
+
this.suggestionDenyListEntries =
|
|
169
|
+
new Resource$Projects$Locations$Collections$Datastores$Suggestiondenylistentries(this.context);
|
|
168
170
|
this.userEvents =
|
|
169
171
|
new Resource$Projects$Locations$Collections$Datastores$Userevents(this.context);
|
|
170
172
|
}
|
|
@@ -200,6 +202,198 @@ var discoveryengine_v1beta;
|
|
|
200
202
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
201
203
|
}
|
|
202
204
|
}
|
|
205
|
+
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
206
|
+
let params = (paramsOrCallback ||
|
|
207
|
+
{});
|
|
208
|
+
let options = (optionsOrCallback || {});
|
|
209
|
+
if (typeof paramsOrCallback === 'function') {
|
|
210
|
+
callback = paramsOrCallback;
|
|
211
|
+
params =
|
|
212
|
+
{};
|
|
213
|
+
options = {};
|
|
214
|
+
}
|
|
215
|
+
if (typeof optionsOrCallback === 'function') {
|
|
216
|
+
callback = optionsOrCallback;
|
|
217
|
+
options = {};
|
|
218
|
+
}
|
|
219
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
220
|
+
const parameters = {
|
|
221
|
+
options: Object.assign({
|
|
222
|
+
url: (rootUrl + '/v1beta/{+parent}/dataStores').replace(/([^:]\/)\/+/g, '$1'),
|
|
223
|
+
method: 'POST',
|
|
224
|
+
}, options),
|
|
225
|
+
params,
|
|
226
|
+
requiredParams: ['parent'],
|
|
227
|
+
pathParams: ['parent'],
|
|
228
|
+
context: this.context,
|
|
229
|
+
};
|
|
230
|
+
if (callback) {
|
|
231
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
232
|
+
}
|
|
233
|
+
else {
|
|
234
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
235
|
+
}
|
|
236
|
+
}
|
|
237
|
+
delete(paramsOrCallback, optionsOrCallback, callback) {
|
|
238
|
+
let params = (paramsOrCallback ||
|
|
239
|
+
{});
|
|
240
|
+
let options = (optionsOrCallback || {});
|
|
241
|
+
if (typeof paramsOrCallback === 'function') {
|
|
242
|
+
callback = paramsOrCallback;
|
|
243
|
+
params =
|
|
244
|
+
{};
|
|
245
|
+
options = {};
|
|
246
|
+
}
|
|
247
|
+
if (typeof optionsOrCallback === 'function') {
|
|
248
|
+
callback = optionsOrCallback;
|
|
249
|
+
options = {};
|
|
250
|
+
}
|
|
251
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
252
|
+
const parameters = {
|
|
253
|
+
options: Object.assign({
|
|
254
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
255
|
+
method: 'DELETE',
|
|
256
|
+
}, options),
|
|
257
|
+
params,
|
|
258
|
+
requiredParams: ['name'],
|
|
259
|
+
pathParams: ['name'],
|
|
260
|
+
context: this.context,
|
|
261
|
+
};
|
|
262
|
+
if (callback) {
|
|
263
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
264
|
+
}
|
|
265
|
+
else {
|
|
266
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
267
|
+
}
|
|
268
|
+
}
|
|
269
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
270
|
+
let params = (paramsOrCallback ||
|
|
271
|
+
{});
|
|
272
|
+
let options = (optionsOrCallback || {});
|
|
273
|
+
if (typeof paramsOrCallback === 'function') {
|
|
274
|
+
callback = paramsOrCallback;
|
|
275
|
+
params =
|
|
276
|
+
{};
|
|
277
|
+
options = {};
|
|
278
|
+
}
|
|
279
|
+
if (typeof optionsOrCallback === 'function') {
|
|
280
|
+
callback = optionsOrCallback;
|
|
281
|
+
options = {};
|
|
282
|
+
}
|
|
283
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
284
|
+
const parameters = {
|
|
285
|
+
options: Object.assign({
|
|
286
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
287
|
+
method: 'GET',
|
|
288
|
+
}, options),
|
|
289
|
+
params,
|
|
290
|
+
requiredParams: ['name'],
|
|
291
|
+
pathParams: ['name'],
|
|
292
|
+
context: this.context,
|
|
293
|
+
};
|
|
294
|
+
if (callback) {
|
|
295
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
296
|
+
}
|
|
297
|
+
else {
|
|
298
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
299
|
+
}
|
|
300
|
+
}
|
|
301
|
+
getSiteSearchEngine(paramsOrCallback, optionsOrCallback, callback) {
|
|
302
|
+
let params = (paramsOrCallback ||
|
|
303
|
+
{});
|
|
304
|
+
let options = (optionsOrCallback || {});
|
|
305
|
+
if (typeof paramsOrCallback === 'function') {
|
|
306
|
+
callback = paramsOrCallback;
|
|
307
|
+
params =
|
|
308
|
+
{};
|
|
309
|
+
options = {};
|
|
310
|
+
}
|
|
311
|
+
if (typeof optionsOrCallback === 'function') {
|
|
312
|
+
callback = optionsOrCallback;
|
|
313
|
+
options = {};
|
|
314
|
+
}
|
|
315
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
316
|
+
const parameters = {
|
|
317
|
+
options: Object.assign({
|
|
318
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
319
|
+
method: 'GET',
|
|
320
|
+
}, options),
|
|
321
|
+
params,
|
|
322
|
+
requiredParams: ['name'],
|
|
323
|
+
pathParams: ['name'],
|
|
324
|
+
context: this.context,
|
|
325
|
+
};
|
|
326
|
+
if (callback) {
|
|
327
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
328
|
+
}
|
|
329
|
+
else {
|
|
330
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
331
|
+
}
|
|
332
|
+
}
|
|
333
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
334
|
+
let params = (paramsOrCallback ||
|
|
335
|
+
{});
|
|
336
|
+
let options = (optionsOrCallback || {});
|
|
337
|
+
if (typeof paramsOrCallback === 'function') {
|
|
338
|
+
callback = paramsOrCallback;
|
|
339
|
+
params =
|
|
340
|
+
{};
|
|
341
|
+
options = {};
|
|
342
|
+
}
|
|
343
|
+
if (typeof optionsOrCallback === 'function') {
|
|
344
|
+
callback = optionsOrCallback;
|
|
345
|
+
options = {};
|
|
346
|
+
}
|
|
347
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
348
|
+
const parameters = {
|
|
349
|
+
options: Object.assign({
|
|
350
|
+
url: (rootUrl + '/v1beta/{+parent}/dataStores').replace(/([^:]\/)\/+/g, '$1'),
|
|
351
|
+
method: 'GET',
|
|
352
|
+
}, options),
|
|
353
|
+
params,
|
|
354
|
+
requiredParams: ['parent'],
|
|
355
|
+
pathParams: ['parent'],
|
|
356
|
+
context: this.context,
|
|
357
|
+
};
|
|
358
|
+
if (callback) {
|
|
359
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
360
|
+
}
|
|
361
|
+
else {
|
|
362
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
363
|
+
}
|
|
364
|
+
}
|
|
365
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
366
|
+
let params = (paramsOrCallback ||
|
|
367
|
+
{});
|
|
368
|
+
let options = (optionsOrCallback || {});
|
|
369
|
+
if (typeof paramsOrCallback === 'function') {
|
|
370
|
+
callback = paramsOrCallback;
|
|
371
|
+
params =
|
|
372
|
+
{};
|
|
373
|
+
options = {};
|
|
374
|
+
}
|
|
375
|
+
if (typeof optionsOrCallback === 'function') {
|
|
376
|
+
callback = optionsOrCallback;
|
|
377
|
+
options = {};
|
|
378
|
+
}
|
|
379
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
380
|
+
const parameters = {
|
|
381
|
+
options: Object.assign({
|
|
382
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
383
|
+
method: 'PATCH',
|
|
384
|
+
}, options),
|
|
385
|
+
params,
|
|
386
|
+
requiredParams: ['name'],
|
|
387
|
+
pathParams: ['name'],
|
|
388
|
+
context: this.context,
|
|
389
|
+
};
|
|
390
|
+
if (callback) {
|
|
391
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
392
|
+
}
|
|
393
|
+
else {
|
|
394
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
395
|
+
}
|
|
396
|
+
}
|
|
203
397
|
}
|
|
204
398
|
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores = Resource$Projects$Locations$Collections$Datastores;
|
|
205
399
|
class Resource$Projects$Locations$Collections$Datastores$Branches {
|
|
@@ -1100,7 +1294,7 @@ var discoveryengine_v1beta;
|
|
|
1100
1294
|
constructor(context) {
|
|
1101
1295
|
this.context = context;
|
|
1102
1296
|
}
|
|
1103
|
-
|
|
1297
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
1104
1298
|
let params = (paramsOrCallback ||
|
|
1105
1299
|
{});
|
|
1106
1300
|
let options = (optionsOrCallback || {});
|
|
@@ -1117,12 +1311,12 @@ var discoveryengine_v1beta;
|
|
|
1117
1311
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1118
1312
|
const parameters = {
|
|
1119
1313
|
options: Object.assign({
|
|
1120
|
-
url: (rootUrl + '/v1beta/{+
|
|
1121
|
-
method: '
|
|
1314
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
1315
|
+
method: 'GET',
|
|
1122
1316
|
}, options),
|
|
1123
1317
|
params,
|
|
1124
|
-
requiredParams: ['
|
|
1125
|
-
pathParams: ['
|
|
1318
|
+
requiredParams: ['name'],
|
|
1319
|
+
pathParams: ['name'],
|
|
1126
1320
|
context: this.context,
|
|
1127
1321
|
};
|
|
1128
1322
|
if (callback) {
|
|
@@ -1132,7 +1326,7 @@ var discoveryengine_v1beta;
|
|
|
1132
1326
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1133
1327
|
}
|
|
1134
1328
|
}
|
|
1135
|
-
|
|
1329
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
1136
1330
|
let params = (paramsOrCallback ||
|
|
1137
1331
|
{});
|
|
1138
1332
|
let options = (optionsOrCallback || {});
|
|
@@ -1149,12 +1343,12 @@ var discoveryengine_v1beta;
|
|
|
1149
1343
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1150
1344
|
const parameters = {
|
|
1151
1345
|
options: Object.assign({
|
|
1152
|
-
url: (rootUrl + '/v1beta/{+
|
|
1153
|
-
method: '
|
|
1346
|
+
url: (rootUrl + '/v1beta/{+parent}/servingConfigs').replace(/([^:]\/)\/+/g, '$1'),
|
|
1347
|
+
method: 'GET',
|
|
1154
1348
|
}, options),
|
|
1155
1349
|
params,
|
|
1156
|
-
requiredParams: ['
|
|
1157
|
-
pathParams: ['
|
|
1350
|
+
requiredParams: ['parent'],
|
|
1351
|
+
pathParams: ['parent'],
|
|
1158
1352
|
context: this.context,
|
|
1159
1353
|
};
|
|
1160
1354
|
if (callback) {
|
|
@@ -1164,23 +1358,7 @@ var discoveryengine_v1beta;
|
|
|
1164
1358
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1165
1359
|
}
|
|
1166
1360
|
}
|
|
1167
|
-
|
|
1168
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Servingconfigs = Resource$Projects$Locations$Collections$Datastores$Servingconfigs;
|
|
1169
|
-
class Resource$Projects$Locations$Collections$Datastores$Sitesearchengine {
|
|
1170
|
-
constructor(context) {
|
|
1171
|
-
this.context = context;
|
|
1172
|
-
this.operations =
|
|
1173
|
-
new Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Operations(this.context);
|
|
1174
|
-
this.targetSites =
|
|
1175
|
-
new Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites(this.context);
|
|
1176
|
-
}
|
|
1177
|
-
}
|
|
1178
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Sitesearchengine = Resource$Projects$Locations$Collections$Datastores$Sitesearchengine;
|
|
1179
|
-
class Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Operations {
|
|
1180
|
-
constructor(context) {
|
|
1181
|
-
this.context = context;
|
|
1182
|
-
}
|
|
1183
|
-
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
1361
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
1184
1362
|
let params = (paramsOrCallback ||
|
|
1185
1363
|
{});
|
|
1186
1364
|
let options = (optionsOrCallback || {});
|
|
@@ -1198,7 +1376,7 @@ var discoveryengine_v1beta;
|
|
|
1198
1376
|
const parameters = {
|
|
1199
1377
|
options: Object.assign({
|
|
1200
1378
|
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
1201
|
-
method: '
|
|
1379
|
+
method: 'PATCH',
|
|
1202
1380
|
}, options),
|
|
1203
1381
|
params,
|
|
1204
1382
|
requiredParams: ['name'],
|
|
@@ -1212,7 +1390,7 @@ var discoveryengine_v1beta;
|
|
|
1212
1390
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1213
1391
|
}
|
|
1214
1392
|
}
|
|
1215
|
-
|
|
1393
|
+
recommend(paramsOrCallback, optionsOrCallback, callback) {
|
|
1216
1394
|
let params = (paramsOrCallback ||
|
|
1217
1395
|
{});
|
|
1218
1396
|
let options = (optionsOrCallback || {});
|
|
@@ -1229,12 +1407,12 @@ var discoveryengine_v1beta;
|
|
|
1229
1407
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1230
1408
|
const parameters = {
|
|
1231
1409
|
options: Object.assign({
|
|
1232
|
-
url: (rootUrl + '/v1beta/{+
|
|
1233
|
-
method: '
|
|
1410
|
+
url: (rootUrl + '/v1beta/{+servingConfig}:recommend').replace(/([^:]\/)\/+/g, '$1'),
|
|
1411
|
+
method: 'POST',
|
|
1234
1412
|
}, options),
|
|
1235
1413
|
params,
|
|
1236
|
-
requiredParams: ['
|
|
1237
|
-
pathParams: ['
|
|
1414
|
+
requiredParams: ['servingConfig'],
|
|
1415
|
+
pathParams: ['servingConfig'],
|
|
1238
1416
|
context: this.context,
|
|
1239
1417
|
};
|
|
1240
1418
|
if (callback) {
|
|
@@ -1244,21 +1422,7 @@ var discoveryengine_v1beta;
|
|
|
1244
1422
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1245
1423
|
}
|
|
1246
1424
|
}
|
|
1247
|
-
|
|
1248
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Operations = Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Operations;
|
|
1249
|
-
class Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites {
|
|
1250
|
-
constructor(context) {
|
|
1251
|
-
this.context = context;
|
|
1252
|
-
this.operations =
|
|
1253
|
-
new Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites$Operations(this.context);
|
|
1254
|
-
}
|
|
1255
|
-
}
|
|
1256
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites = Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites;
|
|
1257
|
-
class Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites$Operations {
|
|
1258
|
-
constructor(context) {
|
|
1259
|
-
this.context = context;
|
|
1260
|
-
}
|
|
1261
|
-
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
1425
|
+
search(paramsOrCallback, optionsOrCallback, callback) {
|
|
1262
1426
|
let params = (paramsOrCallback ||
|
|
1263
1427
|
{});
|
|
1264
1428
|
let options = (optionsOrCallback || {});
|
|
@@ -1275,12 +1439,12 @@ var discoveryengine_v1beta;
|
|
|
1275
1439
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1276
1440
|
const parameters = {
|
|
1277
1441
|
options: Object.assign({
|
|
1278
|
-
url: (rootUrl + '/v1beta/{+
|
|
1279
|
-
method: '
|
|
1442
|
+
url: (rootUrl + '/v1beta/{+servingConfig}:search').replace(/([^:]\/)\/+/g, '$1'),
|
|
1443
|
+
method: 'POST',
|
|
1280
1444
|
}, options),
|
|
1281
1445
|
params,
|
|
1282
|
-
requiredParams: ['
|
|
1283
|
-
pathParams: ['
|
|
1446
|
+
requiredParams: ['servingConfig'],
|
|
1447
|
+
pathParams: ['servingConfig'],
|
|
1284
1448
|
context: this.context,
|
|
1285
1449
|
};
|
|
1286
1450
|
if (callback) {
|
|
@@ -1290,7 +1454,17 @@ var discoveryengine_v1beta;
|
|
|
1290
1454
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1291
1455
|
}
|
|
1292
1456
|
}
|
|
1293
|
-
|
|
1457
|
+
}
|
|
1458
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Servingconfigs = Resource$Projects$Locations$Collections$Datastores$Servingconfigs;
|
|
1459
|
+
class Resource$Projects$Locations$Collections$Datastores$Sitesearchengine {
|
|
1460
|
+
constructor(context) {
|
|
1461
|
+
this.context = context;
|
|
1462
|
+
this.operations =
|
|
1463
|
+
new Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Operations(this.context);
|
|
1464
|
+
this.targetSites =
|
|
1465
|
+
new Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites(this.context);
|
|
1466
|
+
}
|
|
1467
|
+
batchVerifyTargetSites(paramsOrCallback, optionsOrCallback, callback) {
|
|
1294
1468
|
let params = (paramsOrCallback ||
|
|
1295
1469
|
{});
|
|
1296
1470
|
let options = (optionsOrCallback || {});
|
|
@@ -1307,12 +1481,12 @@ var discoveryengine_v1beta;
|
|
|
1307
1481
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1308
1482
|
const parameters = {
|
|
1309
1483
|
options: Object.assign({
|
|
1310
|
-
url: (rootUrl + '/v1beta/{+
|
|
1311
|
-
method: '
|
|
1484
|
+
url: (rootUrl + '/v1beta/{+parent}:batchVerifyTargetSites').replace(/([^:]\/)\/+/g, '$1'),
|
|
1485
|
+
method: 'POST',
|
|
1312
1486
|
}, options),
|
|
1313
1487
|
params,
|
|
1314
|
-
requiredParams: ['
|
|
1315
|
-
pathParams: ['
|
|
1488
|
+
requiredParams: ['parent'],
|
|
1489
|
+
pathParams: ['parent'],
|
|
1316
1490
|
context: this.context,
|
|
1317
1491
|
};
|
|
1318
1492
|
if (callback) {
|
|
@@ -1322,13 +1496,7 @@ var discoveryengine_v1beta;
|
|
|
1322
1496
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1323
1497
|
}
|
|
1324
1498
|
}
|
|
1325
|
-
|
|
1326
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites$Operations = Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites$Operations;
|
|
1327
|
-
class Resource$Projects$Locations$Collections$Datastores$Userevents {
|
|
1328
|
-
constructor(context) {
|
|
1329
|
-
this.context = context;
|
|
1330
|
-
}
|
|
1331
|
-
collect(paramsOrCallback, optionsOrCallback, callback) {
|
|
1499
|
+
disableAdvancedSiteSearch(paramsOrCallback, optionsOrCallback, callback) {
|
|
1332
1500
|
let params = (paramsOrCallback ||
|
|
1333
1501
|
{});
|
|
1334
1502
|
let options = (optionsOrCallback || {});
|
|
@@ -1345,12 +1513,12 @@ var discoveryengine_v1beta;
|
|
|
1345
1513
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1346
1514
|
const parameters = {
|
|
1347
1515
|
options: Object.assign({
|
|
1348
|
-
url: (rootUrl + '/v1beta/{+
|
|
1349
|
-
method: '
|
|
1516
|
+
url: (rootUrl + '/v1beta/{+siteSearchEngine}:disableAdvancedSiteSearch').replace(/([^:]\/)\/+/g, '$1'),
|
|
1517
|
+
method: 'POST',
|
|
1350
1518
|
}, options),
|
|
1351
1519
|
params,
|
|
1352
|
-
requiredParams: ['
|
|
1353
|
-
pathParams: ['
|
|
1520
|
+
requiredParams: ['siteSearchEngine'],
|
|
1521
|
+
pathParams: ['siteSearchEngine'],
|
|
1354
1522
|
context: this.context,
|
|
1355
1523
|
};
|
|
1356
1524
|
if (callback) {
|
|
@@ -1360,7 +1528,7 @@ var discoveryengine_v1beta;
|
|
|
1360
1528
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1361
1529
|
}
|
|
1362
1530
|
}
|
|
1363
|
-
|
|
1531
|
+
enableAdvancedSiteSearch(paramsOrCallback, optionsOrCallback, callback) {
|
|
1364
1532
|
let params = (paramsOrCallback ||
|
|
1365
1533
|
{});
|
|
1366
1534
|
let options = (optionsOrCallback || {});
|
|
@@ -1377,12 +1545,12 @@ var discoveryengine_v1beta;
|
|
|
1377
1545
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1378
1546
|
const parameters = {
|
|
1379
1547
|
options: Object.assign({
|
|
1380
|
-
url: (rootUrl + '/v1beta/{+
|
|
1548
|
+
url: (rootUrl + '/v1beta/{+siteSearchEngine}:enableAdvancedSiteSearch').replace(/([^:]\/)\/+/g, '$1'),
|
|
1381
1549
|
method: 'POST',
|
|
1382
1550
|
}, options),
|
|
1383
1551
|
params,
|
|
1384
|
-
requiredParams: ['
|
|
1385
|
-
pathParams: ['
|
|
1552
|
+
requiredParams: ['siteSearchEngine'],
|
|
1553
|
+
pathParams: ['siteSearchEngine'],
|
|
1386
1554
|
context: this.context,
|
|
1387
1555
|
};
|
|
1388
1556
|
if (callback) {
|
|
@@ -1392,7 +1560,7 @@ var discoveryengine_v1beta;
|
|
|
1392
1560
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1393
1561
|
}
|
|
1394
1562
|
}
|
|
1395
|
-
|
|
1563
|
+
fetchDomainVerificationStatus(paramsOrCallback, optionsOrCallback, callback) {
|
|
1396
1564
|
let params = (paramsOrCallback ||
|
|
1397
1565
|
{});
|
|
1398
1566
|
let options = (optionsOrCallback || {});
|
|
@@ -1409,12 +1577,45 @@ var discoveryengine_v1beta;
|
|
|
1409
1577
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1410
1578
|
const parameters = {
|
|
1411
1579
|
options: Object.assign({
|
|
1412
|
-
url: (rootUrl +
|
|
1580
|
+
url: (rootUrl +
|
|
1581
|
+
'/v1beta/{+siteSearchEngine}:fetchDomainVerificationStatus').replace(/([^:]\/)\/+/g, '$1'),
|
|
1582
|
+
method: 'GET',
|
|
1583
|
+
}, options),
|
|
1584
|
+
params,
|
|
1585
|
+
requiredParams: ['siteSearchEngine'],
|
|
1586
|
+
pathParams: ['siteSearchEngine'],
|
|
1587
|
+
context: this.context,
|
|
1588
|
+
};
|
|
1589
|
+
if (callback) {
|
|
1590
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
1591
|
+
}
|
|
1592
|
+
else {
|
|
1593
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1594
|
+
}
|
|
1595
|
+
}
|
|
1596
|
+
recrawlUris(paramsOrCallback, optionsOrCallback, callback) {
|
|
1597
|
+
let params = (paramsOrCallback ||
|
|
1598
|
+
{});
|
|
1599
|
+
let options = (optionsOrCallback || {});
|
|
1600
|
+
if (typeof paramsOrCallback === 'function') {
|
|
1601
|
+
callback = paramsOrCallback;
|
|
1602
|
+
params =
|
|
1603
|
+
{};
|
|
1604
|
+
options = {};
|
|
1605
|
+
}
|
|
1606
|
+
if (typeof optionsOrCallback === 'function') {
|
|
1607
|
+
callback = optionsOrCallback;
|
|
1608
|
+
options = {};
|
|
1609
|
+
}
|
|
1610
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1611
|
+
const parameters = {
|
|
1612
|
+
options: Object.assign({
|
|
1613
|
+
url: (rootUrl + '/v1beta/{+siteSearchEngine}:recrawlUris').replace(/([^:]\/)\/+/g, '$1'),
|
|
1413
1614
|
method: 'POST',
|
|
1414
1615
|
}, options),
|
|
1415
1616
|
params,
|
|
1416
|
-
requiredParams: ['
|
|
1417
|
-
pathParams: ['
|
|
1617
|
+
requiredParams: ['siteSearchEngine'],
|
|
1618
|
+
pathParams: ['siteSearchEngine'],
|
|
1418
1619
|
context: this.context,
|
|
1419
1620
|
};
|
|
1420
1621
|
if (callback) {
|
|
@@ -1425,24 +1626,84 @@ var discoveryengine_v1beta;
|
|
|
1425
1626
|
}
|
|
1426
1627
|
}
|
|
1427
1628
|
}
|
|
1428
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$
|
|
1429
|
-
class Resource$Projects$Locations$Collections$
|
|
1629
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Sitesearchengine = Resource$Projects$Locations$Collections$Datastores$Sitesearchengine;
|
|
1630
|
+
class Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Operations {
|
|
1430
1631
|
constructor(context) {
|
|
1431
1632
|
this.context = context;
|
|
1432
|
-
|
|
1433
|
-
|
|
1434
|
-
|
|
1435
|
-
|
|
1436
|
-
|
|
1437
|
-
|
|
1633
|
+
}
|
|
1634
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
1635
|
+
let params = (paramsOrCallback ||
|
|
1636
|
+
{});
|
|
1637
|
+
let options = (optionsOrCallback || {});
|
|
1638
|
+
if (typeof paramsOrCallback === 'function') {
|
|
1639
|
+
callback = paramsOrCallback;
|
|
1640
|
+
params =
|
|
1641
|
+
{};
|
|
1642
|
+
options = {};
|
|
1643
|
+
}
|
|
1644
|
+
if (typeof optionsOrCallback === 'function') {
|
|
1645
|
+
callback = optionsOrCallback;
|
|
1646
|
+
options = {};
|
|
1647
|
+
}
|
|
1648
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1649
|
+
const parameters = {
|
|
1650
|
+
options: Object.assign({
|
|
1651
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
1652
|
+
method: 'GET',
|
|
1653
|
+
}, options),
|
|
1654
|
+
params,
|
|
1655
|
+
requiredParams: ['name'],
|
|
1656
|
+
pathParams: ['name'],
|
|
1657
|
+
context: this.context,
|
|
1658
|
+
};
|
|
1659
|
+
if (callback) {
|
|
1660
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
1661
|
+
}
|
|
1662
|
+
else {
|
|
1663
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1664
|
+
}
|
|
1665
|
+
}
|
|
1666
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
1667
|
+
let params = (paramsOrCallback ||
|
|
1668
|
+
{});
|
|
1669
|
+
let options = (optionsOrCallback || {});
|
|
1670
|
+
if (typeof paramsOrCallback === 'function') {
|
|
1671
|
+
callback = paramsOrCallback;
|
|
1672
|
+
params =
|
|
1673
|
+
{};
|
|
1674
|
+
options = {};
|
|
1675
|
+
}
|
|
1676
|
+
if (typeof optionsOrCallback === 'function') {
|
|
1677
|
+
callback = optionsOrCallback;
|
|
1678
|
+
options = {};
|
|
1679
|
+
}
|
|
1680
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1681
|
+
const parameters = {
|
|
1682
|
+
options: Object.assign({
|
|
1683
|
+
url: (rootUrl + '/v1beta/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
|
|
1684
|
+
method: 'GET',
|
|
1685
|
+
}, options),
|
|
1686
|
+
params,
|
|
1687
|
+
requiredParams: ['name'],
|
|
1688
|
+
pathParams: ['name'],
|
|
1689
|
+
context: this.context,
|
|
1690
|
+
};
|
|
1691
|
+
if (callback) {
|
|
1692
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
1693
|
+
}
|
|
1694
|
+
else {
|
|
1695
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1696
|
+
}
|
|
1438
1697
|
}
|
|
1439
1698
|
}
|
|
1440
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$
|
|
1441
|
-
class Resource$Projects$Locations$Collections$
|
|
1699
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Operations = Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Operations;
|
|
1700
|
+
class Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites {
|
|
1442
1701
|
constructor(context) {
|
|
1443
1702
|
this.context = context;
|
|
1703
|
+
this.operations =
|
|
1704
|
+
new Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites$Operations(this.context);
|
|
1444
1705
|
}
|
|
1445
|
-
|
|
1706
|
+
batchCreate(paramsOrCallback, optionsOrCallback, callback) {
|
|
1446
1707
|
let params = (paramsOrCallback ||
|
|
1447
1708
|
{});
|
|
1448
1709
|
let options = (optionsOrCallback || {});
|
|
@@ -1459,12 +1720,12 @@ var discoveryengine_v1beta;
|
|
|
1459
1720
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1460
1721
|
const parameters = {
|
|
1461
1722
|
options: Object.assign({
|
|
1462
|
-
url: (rootUrl + '/v1beta/{+
|
|
1723
|
+
url: (rootUrl + '/v1beta/{+parent}/targetSites:batchCreate').replace(/([^:]\/)\/+/g, '$1'),
|
|
1463
1724
|
method: 'POST',
|
|
1464
1725
|
}, options),
|
|
1465
1726
|
params,
|
|
1466
|
-
requiredParams: ['
|
|
1467
|
-
pathParams: ['
|
|
1727
|
+
requiredParams: ['parent'],
|
|
1728
|
+
pathParams: ['parent'],
|
|
1468
1729
|
context: this.context,
|
|
1469
1730
|
};
|
|
1470
1731
|
if (callback) {
|
|
@@ -1491,7 +1752,7 @@ var discoveryengine_v1beta;
|
|
|
1491
1752
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1492
1753
|
const parameters = {
|
|
1493
1754
|
options: Object.assign({
|
|
1494
|
-
url: (rootUrl + '/v1beta/{+parent}/
|
|
1755
|
+
url: (rootUrl + '/v1beta/{+parent}/targetSites').replace(/([^:]\/)\/+/g, '$1'),
|
|
1495
1756
|
method: 'POST',
|
|
1496
1757
|
}, options),
|
|
1497
1758
|
params,
|
|
@@ -1587,7 +1848,7 @@ var discoveryengine_v1beta;
|
|
|
1587
1848
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1588
1849
|
const parameters = {
|
|
1589
1850
|
options: Object.assign({
|
|
1590
|
-
url: (rootUrl + '/v1beta/{+parent}/
|
|
1851
|
+
url: (rootUrl + '/v1beta/{+parent}/targetSites').replace(/([^:]\/)\/+/g, '$1'),
|
|
1591
1852
|
method: 'GET',
|
|
1592
1853
|
}, options),
|
|
1593
1854
|
params,
|
|
@@ -1635,8 +1896,8 @@ var discoveryengine_v1beta;
|
|
|
1635
1896
|
}
|
|
1636
1897
|
}
|
|
1637
1898
|
}
|
|
1638
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$
|
|
1639
|
-
class Resource$Projects$Locations$Collections$
|
|
1899
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites = Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites;
|
|
1900
|
+
class Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites$Operations {
|
|
1640
1901
|
constructor(context) {
|
|
1641
1902
|
this.context = context;
|
|
1642
1903
|
}
|
|
@@ -1705,12 +1966,12 @@ var discoveryengine_v1beta;
|
|
|
1705
1966
|
}
|
|
1706
1967
|
}
|
|
1707
1968
|
}
|
|
1708
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$
|
|
1709
|
-
class Resource$Projects$Locations$Collections$
|
|
1969
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites$Operations = Resource$Projects$Locations$Collections$Datastores$Sitesearchengine$Targetsites$Operations;
|
|
1970
|
+
class Resource$Projects$Locations$Collections$Datastores$Suggestiondenylistentries {
|
|
1710
1971
|
constructor(context) {
|
|
1711
1972
|
this.context = context;
|
|
1712
1973
|
}
|
|
1713
|
-
|
|
1974
|
+
import(paramsOrCallback, optionsOrCallback, callback) {
|
|
1714
1975
|
let params = (paramsOrCallback ||
|
|
1715
1976
|
{});
|
|
1716
1977
|
let options = (optionsOrCallback || {});
|
|
@@ -1727,12 +1988,12 @@ var discoveryengine_v1beta;
|
|
|
1727
1988
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1728
1989
|
const parameters = {
|
|
1729
1990
|
options: Object.assign({
|
|
1730
|
-
url: (rootUrl + '/v1beta/{+
|
|
1991
|
+
url: (rootUrl + '/v1beta/{+parent}/suggestionDenyListEntries:import').replace(/([^:]\/)\/+/g, '$1'),
|
|
1731
1992
|
method: 'POST',
|
|
1732
1993
|
}, options),
|
|
1733
1994
|
params,
|
|
1734
|
-
requiredParams: ['
|
|
1735
|
-
pathParams: ['
|
|
1995
|
+
requiredParams: ['parent'],
|
|
1996
|
+
pathParams: ['parent'],
|
|
1736
1997
|
context: this.context,
|
|
1737
1998
|
};
|
|
1738
1999
|
if (callback) {
|
|
@@ -1742,7 +2003,7 @@ var discoveryengine_v1beta;
|
|
|
1742
2003
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1743
2004
|
}
|
|
1744
2005
|
}
|
|
1745
|
-
|
|
2006
|
+
purge(paramsOrCallback, optionsOrCallback, callback) {
|
|
1746
2007
|
let params = (paramsOrCallback ||
|
|
1747
2008
|
{});
|
|
1748
2009
|
let options = (optionsOrCallback || {});
|
|
@@ -1759,12 +2020,12 @@ var discoveryengine_v1beta;
|
|
|
1759
2020
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1760
2021
|
const parameters = {
|
|
1761
2022
|
options: Object.assign({
|
|
1762
|
-
url: (rootUrl + '/v1beta/{+
|
|
2023
|
+
url: (rootUrl + '/v1beta/{+parent}/suggestionDenyListEntries:purge').replace(/([^:]\/)\/+/g, '$1'),
|
|
1763
2024
|
method: 'POST',
|
|
1764
2025
|
}, options),
|
|
1765
2026
|
params,
|
|
1766
|
-
requiredParams: ['
|
|
1767
|
-
pathParams: ['
|
|
2027
|
+
requiredParams: ['parent'],
|
|
2028
|
+
pathParams: ['parent'],
|
|
1768
2029
|
context: this.context,
|
|
1769
2030
|
};
|
|
1770
2031
|
if (callback) {
|
|
@@ -1775,12 +2036,12 @@ var discoveryengine_v1beta;
|
|
|
1775
2036
|
}
|
|
1776
2037
|
}
|
|
1777
2038
|
}
|
|
1778
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$
|
|
1779
|
-
class Resource$Projects$Locations$Collections$
|
|
2039
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Suggestiondenylistentries = Resource$Projects$Locations$Collections$Datastores$Suggestiondenylistentries;
|
|
2040
|
+
class Resource$Projects$Locations$Collections$Datastores$Userevents {
|
|
1780
2041
|
constructor(context) {
|
|
1781
2042
|
this.context = context;
|
|
1782
2043
|
}
|
|
1783
|
-
|
|
2044
|
+
collect(paramsOrCallback, optionsOrCallback, callback) {
|
|
1784
2045
|
let params = (paramsOrCallback ||
|
|
1785
2046
|
{});
|
|
1786
2047
|
let options = (optionsOrCallback || {});
|
|
@@ -1797,12 +2058,12 @@ var discoveryengine_v1beta;
|
|
|
1797
2058
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1798
2059
|
const parameters = {
|
|
1799
2060
|
options: Object.assign({
|
|
1800
|
-
url: (rootUrl + '/v1beta/{+
|
|
2061
|
+
url: (rootUrl + '/v1beta/{+parent}/userEvents:collect').replace(/([^:]\/)\/+/g, '$1'),
|
|
1801
2062
|
method: 'GET',
|
|
1802
2063
|
}, options),
|
|
1803
2064
|
params,
|
|
1804
|
-
requiredParams: ['
|
|
1805
|
-
pathParams: ['
|
|
2065
|
+
requiredParams: ['parent'],
|
|
2066
|
+
pathParams: ['parent'],
|
|
1806
2067
|
context: this.context,
|
|
1807
2068
|
};
|
|
1808
2069
|
if (callback) {
|
|
@@ -1812,7 +2073,7 @@ var discoveryengine_v1beta;
|
|
|
1812
2073
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1813
2074
|
}
|
|
1814
2075
|
}
|
|
1815
|
-
|
|
2076
|
+
import(paramsOrCallback, optionsOrCallback, callback) {
|
|
1816
2077
|
let params = (paramsOrCallback ||
|
|
1817
2078
|
{});
|
|
1818
2079
|
let options = (optionsOrCallback || {});
|
|
@@ -1829,12 +2090,44 @@ var discoveryengine_v1beta;
|
|
|
1829
2090
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1830
2091
|
const parameters = {
|
|
1831
2092
|
options: Object.assign({
|
|
1832
|
-
url: (rootUrl + '/v1beta/{+
|
|
1833
|
-
method: '
|
|
2093
|
+
url: (rootUrl + '/v1beta/{+parent}/userEvents:import').replace(/([^:]\/)\/+/g, '$1'),
|
|
2094
|
+
method: 'POST',
|
|
1834
2095
|
}, options),
|
|
1835
2096
|
params,
|
|
1836
|
-
requiredParams: ['
|
|
1837
|
-
pathParams: ['
|
|
2097
|
+
requiredParams: ['parent'],
|
|
2098
|
+
pathParams: ['parent'],
|
|
2099
|
+
context: this.context,
|
|
2100
|
+
};
|
|
2101
|
+
if (callback) {
|
|
2102
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2103
|
+
}
|
|
2104
|
+
else {
|
|
2105
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2106
|
+
}
|
|
2107
|
+
}
|
|
2108
|
+
write(paramsOrCallback, optionsOrCallback, callback) {
|
|
2109
|
+
let params = (paramsOrCallback ||
|
|
2110
|
+
{});
|
|
2111
|
+
let options = (optionsOrCallback || {});
|
|
2112
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2113
|
+
callback = paramsOrCallback;
|
|
2114
|
+
params =
|
|
2115
|
+
{};
|
|
2116
|
+
options = {};
|
|
2117
|
+
}
|
|
2118
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2119
|
+
callback = optionsOrCallback;
|
|
2120
|
+
options = {};
|
|
2121
|
+
}
|
|
2122
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2123
|
+
const parameters = {
|
|
2124
|
+
options: Object.assign({
|
|
2125
|
+
url: (rootUrl + '/v1beta/{+parent}/userEvents:write').replace(/([^:]\/)\/+/g, '$1'),
|
|
2126
|
+
method: 'POST',
|
|
2127
|
+
}, options),
|
|
2128
|
+
params,
|
|
2129
|
+
requiredParams: ['parent'],
|
|
2130
|
+
pathParams: ['parent'],
|
|
1838
2131
|
context: this.context,
|
|
1839
2132
|
};
|
|
1840
2133
|
if (callback) {
|
|
@@ -1845,21 +2138,1364 @@ var discoveryengine_v1beta;
|
|
|
1845
2138
|
}
|
|
1846
2139
|
}
|
|
1847
2140
|
}
|
|
1848
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Collections$
|
|
1849
|
-
class Resource$Projects$Locations$
|
|
2141
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Datastores$Userevents = Resource$Projects$Locations$Collections$Datastores$Userevents;
|
|
2142
|
+
class Resource$Projects$Locations$Collections$Engines {
|
|
1850
2143
|
constructor(context) {
|
|
1851
2144
|
this.context = context;
|
|
1852
|
-
this.branches = new Resource$Projects$Locations$Datastores$Branches(this.context);
|
|
1853
2145
|
this.conversations =
|
|
1854
|
-
new Resource$Projects$Locations$
|
|
1855
|
-
this.
|
|
1856
|
-
|
|
1857
|
-
this.schemas = new Resource$Projects$Locations$Datastores$Schemas(this.context);
|
|
2146
|
+
new Resource$Projects$Locations$Collections$Engines$Conversations(this.context);
|
|
2147
|
+
this.operations =
|
|
2148
|
+
new Resource$Projects$Locations$Collections$Engines$Operations(this.context);
|
|
1858
2149
|
this.servingConfigs =
|
|
1859
|
-
new Resource$Projects$Locations$
|
|
1860
|
-
|
|
2150
|
+
new Resource$Projects$Locations$Collections$Engines$Servingconfigs(this.context);
|
|
2151
|
+
}
|
|
2152
|
+
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
2153
|
+
let params = (paramsOrCallback ||
|
|
2154
|
+
{});
|
|
2155
|
+
let options = (optionsOrCallback || {});
|
|
2156
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2157
|
+
callback = paramsOrCallback;
|
|
2158
|
+
params =
|
|
2159
|
+
{};
|
|
2160
|
+
options = {};
|
|
2161
|
+
}
|
|
2162
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2163
|
+
callback = optionsOrCallback;
|
|
2164
|
+
options = {};
|
|
2165
|
+
}
|
|
2166
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2167
|
+
const parameters = {
|
|
2168
|
+
options: Object.assign({
|
|
2169
|
+
url: (rootUrl + '/v1beta/{+parent}/engines').replace(/([^:]\/)\/+/g, '$1'),
|
|
2170
|
+
method: 'POST',
|
|
2171
|
+
}, options),
|
|
2172
|
+
params,
|
|
2173
|
+
requiredParams: ['parent'],
|
|
2174
|
+
pathParams: ['parent'],
|
|
2175
|
+
context: this.context,
|
|
2176
|
+
};
|
|
2177
|
+
if (callback) {
|
|
2178
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2179
|
+
}
|
|
2180
|
+
else {
|
|
2181
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2182
|
+
}
|
|
2183
|
+
}
|
|
2184
|
+
delete(paramsOrCallback, optionsOrCallback, callback) {
|
|
2185
|
+
let params = (paramsOrCallback ||
|
|
2186
|
+
{});
|
|
2187
|
+
let options = (optionsOrCallback || {});
|
|
2188
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2189
|
+
callback = paramsOrCallback;
|
|
2190
|
+
params =
|
|
2191
|
+
{};
|
|
2192
|
+
options = {};
|
|
2193
|
+
}
|
|
2194
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2195
|
+
callback = optionsOrCallback;
|
|
2196
|
+
options = {};
|
|
2197
|
+
}
|
|
2198
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2199
|
+
const parameters = {
|
|
2200
|
+
options: Object.assign({
|
|
2201
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2202
|
+
method: 'DELETE',
|
|
2203
|
+
}, options),
|
|
2204
|
+
params,
|
|
2205
|
+
requiredParams: ['name'],
|
|
2206
|
+
pathParams: ['name'],
|
|
2207
|
+
context: this.context,
|
|
2208
|
+
};
|
|
2209
|
+
if (callback) {
|
|
2210
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2211
|
+
}
|
|
2212
|
+
else {
|
|
2213
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2214
|
+
}
|
|
2215
|
+
}
|
|
2216
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2217
|
+
let params = (paramsOrCallback ||
|
|
2218
|
+
{});
|
|
2219
|
+
let options = (optionsOrCallback || {});
|
|
2220
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2221
|
+
callback = paramsOrCallback;
|
|
2222
|
+
params =
|
|
2223
|
+
{};
|
|
2224
|
+
options = {};
|
|
2225
|
+
}
|
|
2226
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2227
|
+
callback = optionsOrCallback;
|
|
2228
|
+
options = {};
|
|
2229
|
+
}
|
|
2230
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2231
|
+
const parameters = {
|
|
2232
|
+
options: Object.assign({
|
|
2233
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2234
|
+
method: 'GET',
|
|
2235
|
+
}, options),
|
|
2236
|
+
params,
|
|
2237
|
+
requiredParams: ['name'],
|
|
2238
|
+
pathParams: ['name'],
|
|
2239
|
+
context: this.context,
|
|
2240
|
+
};
|
|
2241
|
+
if (callback) {
|
|
2242
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2243
|
+
}
|
|
2244
|
+
else {
|
|
2245
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2246
|
+
}
|
|
2247
|
+
}
|
|
2248
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
2249
|
+
let params = (paramsOrCallback ||
|
|
2250
|
+
{});
|
|
2251
|
+
let options = (optionsOrCallback || {});
|
|
2252
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2253
|
+
callback = paramsOrCallback;
|
|
2254
|
+
params =
|
|
2255
|
+
{};
|
|
2256
|
+
options = {};
|
|
2257
|
+
}
|
|
2258
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2259
|
+
callback = optionsOrCallback;
|
|
2260
|
+
options = {};
|
|
2261
|
+
}
|
|
2262
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2263
|
+
const parameters = {
|
|
2264
|
+
options: Object.assign({
|
|
2265
|
+
url: (rootUrl + '/v1beta/{+parent}/engines').replace(/([^:]\/)\/+/g, '$1'),
|
|
2266
|
+
method: 'GET',
|
|
2267
|
+
}, options),
|
|
2268
|
+
params,
|
|
2269
|
+
requiredParams: ['parent'],
|
|
2270
|
+
pathParams: ['parent'],
|
|
2271
|
+
context: this.context,
|
|
2272
|
+
};
|
|
2273
|
+
if (callback) {
|
|
2274
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2275
|
+
}
|
|
2276
|
+
else {
|
|
2277
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2278
|
+
}
|
|
2279
|
+
}
|
|
2280
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
2281
|
+
let params = (paramsOrCallback ||
|
|
2282
|
+
{});
|
|
2283
|
+
let options = (optionsOrCallback || {});
|
|
2284
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2285
|
+
callback = paramsOrCallback;
|
|
2286
|
+
params =
|
|
2287
|
+
{};
|
|
2288
|
+
options = {};
|
|
2289
|
+
}
|
|
2290
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2291
|
+
callback = optionsOrCallback;
|
|
2292
|
+
options = {};
|
|
2293
|
+
}
|
|
2294
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2295
|
+
const parameters = {
|
|
2296
|
+
options: Object.assign({
|
|
2297
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2298
|
+
method: 'PATCH',
|
|
2299
|
+
}, options),
|
|
2300
|
+
params,
|
|
2301
|
+
requiredParams: ['name'],
|
|
2302
|
+
pathParams: ['name'],
|
|
2303
|
+
context: this.context,
|
|
2304
|
+
};
|
|
2305
|
+
if (callback) {
|
|
2306
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2307
|
+
}
|
|
2308
|
+
else {
|
|
2309
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2310
|
+
}
|
|
2311
|
+
}
|
|
2312
|
+
}
|
|
2313
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Engines = Resource$Projects$Locations$Collections$Engines;
|
|
2314
|
+
class Resource$Projects$Locations$Collections$Engines$Conversations {
|
|
2315
|
+
constructor(context) {
|
|
2316
|
+
this.context = context;
|
|
2317
|
+
}
|
|
2318
|
+
converse(paramsOrCallback, optionsOrCallback, callback) {
|
|
2319
|
+
let params = (paramsOrCallback ||
|
|
2320
|
+
{});
|
|
2321
|
+
let options = (optionsOrCallback || {});
|
|
2322
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2323
|
+
callback = paramsOrCallback;
|
|
2324
|
+
params =
|
|
2325
|
+
{};
|
|
2326
|
+
options = {};
|
|
2327
|
+
}
|
|
2328
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2329
|
+
callback = optionsOrCallback;
|
|
2330
|
+
options = {};
|
|
2331
|
+
}
|
|
2332
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2333
|
+
const parameters = {
|
|
2334
|
+
options: Object.assign({
|
|
2335
|
+
url: (rootUrl + '/v1beta/{+name}:converse').replace(/([^:]\/)\/+/g, '$1'),
|
|
2336
|
+
method: 'POST',
|
|
2337
|
+
}, options),
|
|
2338
|
+
params,
|
|
2339
|
+
requiredParams: ['name'],
|
|
2340
|
+
pathParams: ['name'],
|
|
2341
|
+
context: this.context,
|
|
2342
|
+
};
|
|
2343
|
+
if (callback) {
|
|
2344
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2345
|
+
}
|
|
2346
|
+
else {
|
|
2347
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2348
|
+
}
|
|
2349
|
+
}
|
|
2350
|
+
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
2351
|
+
let params = (paramsOrCallback ||
|
|
2352
|
+
{});
|
|
2353
|
+
let options = (optionsOrCallback || {});
|
|
2354
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2355
|
+
callback = paramsOrCallback;
|
|
2356
|
+
params =
|
|
2357
|
+
{};
|
|
2358
|
+
options = {};
|
|
2359
|
+
}
|
|
2360
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2361
|
+
callback = optionsOrCallback;
|
|
2362
|
+
options = {};
|
|
2363
|
+
}
|
|
2364
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2365
|
+
const parameters = {
|
|
2366
|
+
options: Object.assign({
|
|
2367
|
+
url: (rootUrl + '/v1beta/{+parent}/conversations').replace(/([^:]\/)\/+/g, '$1'),
|
|
2368
|
+
method: 'POST',
|
|
2369
|
+
}, options),
|
|
2370
|
+
params,
|
|
2371
|
+
requiredParams: ['parent'],
|
|
2372
|
+
pathParams: ['parent'],
|
|
2373
|
+
context: this.context,
|
|
2374
|
+
};
|
|
2375
|
+
if (callback) {
|
|
2376
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2377
|
+
}
|
|
2378
|
+
else {
|
|
2379
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2380
|
+
}
|
|
2381
|
+
}
|
|
2382
|
+
delete(paramsOrCallback, optionsOrCallback, callback) {
|
|
2383
|
+
let params = (paramsOrCallback ||
|
|
2384
|
+
{});
|
|
2385
|
+
let options = (optionsOrCallback || {});
|
|
2386
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2387
|
+
callback = paramsOrCallback;
|
|
2388
|
+
params =
|
|
2389
|
+
{};
|
|
2390
|
+
options = {};
|
|
2391
|
+
}
|
|
2392
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2393
|
+
callback = optionsOrCallback;
|
|
2394
|
+
options = {};
|
|
2395
|
+
}
|
|
2396
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2397
|
+
const parameters = {
|
|
2398
|
+
options: Object.assign({
|
|
2399
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2400
|
+
method: 'DELETE',
|
|
2401
|
+
}, options),
|
|
2402
|
+
params,
|
|
2403
|
+
requiredParams: ['name'],
|
|
2404
|
+
pathParams: ['name'],
|
|
2405
|
+
context: this.context,
|
|
2406
|
+
};
|
|
2407
|
+
if (callback) {
|
|
2408
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2409
|
+
}
|
|
2410
|
+
else {
|
|
2411
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2412
|
+
}
|
|
2413
|
+
}
|
|
2414
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2415
|
+
let params = (paramsOrCallback ||
|
|
2416
|
+
{});
|
|
2417
|
+
let options = (optionsOrCallback || {});
|
|
2418
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2419
|
+
callback = paramsOrCallback;
|
|
2420
|
+
params =
|
|
2421
|
+
{};
|
|
2422
|
+
options = {};
|
|
2423
|
+
}
|
|
2424
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2425
|
+
callback = optionsOrCallback;
|
|
2426
|
+
options = {};
|
|
2427
|
+
}
|
|
2428
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2429
|
+
const parameters = {
|
|
2430
|
+
options: Object.assign({
|
|
2431
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2432
|
+
method: 'GET',
|
|
2433
|
+
}, options),
|
|
2434
|
+
params,
|
|
2435
|
+
requiredParams: ['name'],
|
|
2436
|
+
pathParams: ['name'],
|
|
2437
|
+
context: this.context,
|
|
2438
|
+
};
|
|
2439
|
+
if (callback) {
|
|
2440
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2441
|
+
}
|
|
2442
|
+
else {
|
|
2443
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2444
|
+
}
|
|
2445
|
+
}
|
|
2446
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
2447
|
+
let params = (paramsOrCallback ||
|
|
2448
|
+
{});
|
|
2449
|
+
let options = (optionsOrCallback || {});
|
|
2450
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2451
|
+
callback = paramsOrCallback;
|
|
2452
|
+
params =
|
|
2453
|
+
{};
|
|
2454
|
+
options = {};
|
|
2455
|
+
}
|
|
2456
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2457
|
+
callback = optionsOrCallback;
|
|
2458
|
+
options = {};
|
|
2459
|
+
}
|
|
2460
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2461
|
+
const parameters = {
|
|
2462
|
+
options: Object.assign({
|
|
2463
|
+
url: (rootUrl + '/v1beta/{+parent}/conversations').replace(/([^:]\/)\/+/g, '$1'),
|
|
2464
|
+
method: 'GET',
|
|
2465
|
+
}, options),
|
|
2466
|
+
params,
|
|
2467
|
+
requiredParams: ['parent'],
|
|
2468
|
+
pathParams: ['parent'],
|
|
2469
|
+
context: this.context,
|
|
2470
|
+
};
|
|
2471
|
+
if (callback) {
|
|
2472
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2473
|
+
}
|
|
2474
|
+
else {
|
|
2475
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2476
|
+
}
|
|
2477
|
+
}
|
|
2478
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
2479
|
+
let params = (paramsOrCallback ||
|
|
2480
|
+
{});
|
|
2481
|
+
let options = (optionsOrCallback || {});
|
|
2482
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2483
|
+
callback = paramsOrCallback;
|
|
2484
|
+
params =
|
|
2485
|
+
{};
|
|
2486
|
+
options = {};
|
|
2487
|
+
}
|
|
2488
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2489
|
+
callback = optionsOrCallback;
|
|
2490
|
+
options = {};
|
|
2491
|
+
}
|
|
2492
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2493
|
+
const parameters = {
|
|
2494
|
+
options: Object.assign({
|
|
2495
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2496
|
+
method: 'PATCH',
|
|
2497
|
+
}, options),
|
|
2498
|
+
params,
|
|
2499
|
+
requiredParams: ['name'],
|
|
2500
|
+
pathParams: ['name'],
|
|
2501
|
+
context: this.context,
|
|
2502
|
+
};
|
|
2503
|
+
if (callback) {
|
|
2504
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2505
|
+
}
|
|
2506
|
+
else {
|
|
2507
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2508
|
+
}
|
|
2509
|
+
}
|
|
2510
|
+
}
|
|
2511
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Engines$Conversations = Resource$Projects$Locations$Collections$Engines$Conversations;
|
|
2512
|
+
class Resource$Projects$Locations$Collections$Engines$Operations {
|
|
2513
|
+
constructor(context) {
|
|
2514
|
+
this.context = context;
|
|
2515
|
+
}
|
|
2516
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2517
|
+
let params = (paramsOrCallback ||
|
|
2518
|
+
{});
|
|
2519
|
+
let options = (optionsOrCallback || {});
|
|
2520
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2521
|
+
callback = paramsOrCallback;
|
|
2522
|
+
params =
|
|
2523
|
+
{};
|
|
2524
|
+
options = {};
|
|
2525
|
+
}
|
|
2526
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2527
|
+
callback = optionsOrCallback;
|
|
2528
|
+
options = {};
|
|
2529
|
+
}
|
|
2530
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2531
|
+
const parameters = {
|
|
2532
|
+
options: Object.assign({
|
|
2533
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2534
|
+
method: 'GET',
|
|
2535
|
+
}, options),
|
|
2536
|
+
params,
|
|
2537
|
+
requiredParams: ['name'],
|
|
2538
|
+
pathParams: ['name'],
|
|
2539
|
+
context: this.context,
|
|
2540
|
+
};
|
|
2541
|
+
if (callback) {
|
|
2542
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2543
|
+
}
|
|
2544
|
+
else {
|
|
2545
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2546
|
+
}
|
|
2547
|
+
}
|
|
2548
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
2549
|
+
let params = (paramsOrCallback ||
|
|
2550
|
+
{});
|
|
2551
|
+
let options = (optionsOrCallback || {});
|
|
2552
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2553
|
+
callback = paramsOrCallback;
|
|
2554
|
+
params =
|
|
2555
|
+
{};
|
|
2556
|
+
options = {};
|
|
2557
|
+
}
|
|
2558
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2559
|
+
callback = optionsOrCallback;
|
|
2560
|
+
options = {};
|
|
2561
|
+
}
|
|
2562
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2563
|
+
const parameters = {
|
|
2564
|
+
options: Object.assign({
|
|
2565
|
+
url: (rootUrl + '/v1beta/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
|
|
2566
|
+
method: 'GET',
|
|
2567
|
+
}, options),
|
|
2568
|
+
params,
|
|
2569
|
+
requiredParams: ['name'],
|
|
2570
|
+
pathParams: ['name'],
|
|
2571
|
+
context: this.context,
|
|
2572
|
+
};
|
|
2573
|
+
if (callback) {
|
|
2574
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2575
|
+
}
|
|
2576
|
+
else {
|
|
2577
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2578
|
+
}
|
|
2579
|
+
}
|
|
2580
|
+
}
|
|
2581
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Engines$Operations = Resource$Projects$Locations$Collections$Engines$Operations;
|
|
2582
|
+
class Resource$Projects$Locations$Collections$Engines$Servingconfigs {
|
|
2583
|
+
constructor(context) {
|
|
2584
|
+
this.context = context;
|
|
2585
|
+
}
|
|
2586
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2587
|
+
let params = (paramsOrCallback ||
|
|
2588
|
+
{});
|
|
2589
|
+
let options = (optionsOrCallback || {});
|
|
2590
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2591
|
+
callback = paramsOrCallback;
|
|
2592
|
+
params =
|
|
2593
|
+
{};
|
|
2594
|
+
options = {};
|
|
2595
|
+
}
|
|
2596
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2597
|
+
callback = optionsOrCallback;
|
|
2598
|
+
options = {};
|
|
2599
|
+
}
|
|
2600
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2601
|
+
const parameters = {
|
|
2602
|
+
options: Object.assign({
|
|
2603
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2604
|
+
method: 'GET',
|
|
2605
|
+
}, options),
|
|
2606
|
+
params,
|
|
2607
|
+
requiredParams: ['name'],
|
|
2608
|
+
pathParams: ['name'],
|
|
2609
|
+
context: this.context,
|
|
2610
|
+
};
|
|
2611
|
+
if (callback) {
|
|
2612
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2613
|
+
}
|
|
2614
|
+
else {
|
|
2615
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2616
|
+
}
|
|
2617
|
+
}
|
|
2618
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
2619
|
+
let params = (paramsOrCallback ||
|
|
2620
|
+
{});
|
|
2621
|
+
let options = (optionsOrCallback || {});
|
|
2622
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2623
|
+
callback = paramsOrCallback;
|
|
2624
|
+
params =
|
|
2625
|
+
{};
|
|
2626
|
+
options = {};
|
|
2627
|
+
}
|
|
2628
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2629
|
+
callback = optionsOrCallback;
|
|
2630
|
+
options = {};
|
|
2631
|
+
}
|
|
2632
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2633
|
+
const parameters = {
|
|
2634
|
+
options: Object.assign({
|
|
2635
|
+
url: (rootUrl + '/v1beta/{+parent}/servingConfigs').replace(/([^:]\/)\/+/g, '$1'),
|
|
2636
|
+
method: 'GET',
|
|
2637
|
+
}, options),
|
|
2638
|
+
params,
|
|
2639
|
+
requiredParams: ['parent'],
|
|
2640
|
+
pathParams: ['parent'],
|
|
2641
|
+
context: this.context,
|
|
2642
|
+
};
|
|
2643
|
+
if (callback) {
|
|
2644
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2645
|
+
}
|
|
2646
|
+
else {
|
|
2647
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2648
|
+
}
|
|
2649
|
+
}
|
|
2650
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
2651
|
+
let params = (paramsOrCallback ||
|
|
2652
|
+
{});
|
|
2653
|
+
let options = (optionsOrCallback || {});
|
|
2654
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2655
|
+
callback = paramsOrCallback;
|
|
2656
|
+
params =
|
|
2657
|
+
{};
|
|
2658
|
+
options = {};
|
|
2659
|
+
}
|
|
2660
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2661
|
+
callback = optionsOrCallback;
|
|
2662
|
+
options = {};
|
|
2663
|
+
}
|
|
2664
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2665
|
+
const parameters = {
|
|
2666
|
+
options: Object.assign({
|
|
2667
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2668
|
+
method: 'PATCH',
|
|
2669
|
+
}, options),
|
|
2670
|
+
params,
|
|
2671
|
+
requiredParams: ['name'],
|
|
2672
|
+
pathParams: ['name'],
|
|
2673
|
+
context: this.context,
|
|
2674
|
+
};
|
|
2675
|
+
if (callback) {
|
|
2676
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2677
|
+
}
|
|
2678
|
+
else {
|
|
2679
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2680
|
+
}
|
|
2681
|
+
}
|
|
2682
|
+
recommend(paramsOrCallback, optionsOrCallback, callback) {
|
|
2683
|
+
let params = (paramsOrCallback ||
|
|
2684
|
+
{});
|
|
2685
|
+
let options = (optionsOrCallback || {});
|
|
2686
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2687
|
+
callback = paramsOrCallback;
|
|
2688
|
+
params =
|
|
2689
|
+
{};
|
|
2690
|
+
options = {};
|
|
2691
|
+
}
|
|
2692
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2693
|
+
callback = optionsOrCallback;
|
|
2694
|
+
options = {};
|
|
2695
|
+
}
|
|
2696
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2697
|
+
const parameters = {
|
|
2698
|
+
options: Object.assign({
|
|
2699
|
+
url: (rootUrl + '/v1beta/{+servingConfig}:recommend').replace(/([^:]\/)\/+/g, '$1'),
|
|
2700
|
+
method: 'POST',
|
|
2701
|
+
}, options),
|
|
2702
|
+
params,
|
|
2703
|
+
requiredParams: ['servingConfig'],
|
|
2704
|
+
pathParams: ['servingConfig'],
|
|
2705
|
+
context: this.context,
|
|
2706
|
+
};
|
|
2707
|
+
if (callback) {
|
|
2708
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2709
|
+
}
|
|
2710
|
+
else {
|
|
2711
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2712
|
+
}
|
|
2713
|
+
}
|
|
2714
|
+
search(paramsOrCallback, optionsOrCallback, callback) {
|
|
2715
|
+
let params = (paramsOrCallback ||
|
|
2716
|
+
{});
|
|
2717
|
+
let options = (optionsOrCallback || {});
|
|
2718
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2719
|
+
callback = paramsOrCallback;
|
|
2720
|
+
params =
|
|
2721
|
+
{};
|
|
2722
|
+
options = {};
|
|
2723
|
+
}
|
|
2724
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2725
|
+
callback = optionsOrCallback;
|
|
2726
|
+
options = {};
|
|
2727
|
+
}
|
|
2728
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2729
|
+
const parameters = {
|
|
2730
|
+
options: Object.assign({
|
|
2731
|
+
url: (rootUrl + '/v1beta/{+servingConfig}:search').replace(/([^:]\/)\/+/g, '$1'),
|
|
2732
|
+
method: 'POST',
|
|
2733
|
+
}, options),
|
|
2734
|
+
params,
|
|
2735
|
+
requiredParams: ['servingConfig'],
|
|
2736
|
+
pathParams: ['servingConfig'],
|
|
2737
|
+
context: this.context,
|
|
2738
|
+
};
|
|
2739
|
+
if (callback) {
|
|
2740
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2741
|
+
}
|
|
2742
|
+
else {
|
|
2743
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2744
|
+
}
|
|
2745
|
+
}
|
|
2746
|
+
}
|
|
2747
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Engines$Servingconfigs = Resource$Projects$Locations$Collections$Engines$Servingconfigs;
|
|
2748
|
+
class Resource$Projects$Locations$Collections$Operations {
|
|
2749
|
+
constructor(context) {
|
|
2750
|
+
this.context = context;
|
|
2751
|
+
}
|
|
2752
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2753
|
+
let params = (paramsOrCallback ||
|
|
2754
|
+
{});
|
|
2755
|
+
let options = (optionsOrCallback || {});
|
|
2756
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2757
|
+
callback = paramsOrCallback;
|
|
2758
|
+
params =
|
|
2759
|
+
{};
|
|
2760
|
+
options = {};
|
|
2761
|
+
}
|
|
2762
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2763
|
+
callback = optionsOrCallback;
|
|
2764
|
+
options = {};
|
|
2765
|
+
}
|
|
2766
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2767
|
+
const parameters = {
|
|
2768
|
+
options: Object.assign({
|
|
2769
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2770
|
+
method: 'GET',
|
|
2771
|
+
}, options),
|
|
2772
|
+
params,
|
|
2773
|
+
requiredParams: ['name'],
|
|
2774
|
+
pathParams: ['name'],
|
|
2775
|
+
context: this.context,
|
|
2776
|
+
};
|
|
2777
|
+
if (callback) {
|
|
2778
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2779
|
+
}
|
|
2780
|
+
else {
|
|
2781
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2782
|
+
}
|
|
2783
|
+
}
|
|
2784
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
2785
|
+
let params = (paramsOrCallback ||
|
|
2786
|
+
{});
|
|
2787
|
+
let options = (optionsOrCallback || {});
|
|
2788
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2789
|
+
callback = paramsOrCallback;
|
|
2790
|
+
params =
|
|
2791
|
+
{};
|
|
2792
|
+
options = {};
|
|
2793
|
+
}
|
|
2794
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2795
|
+
callback = optionsOrCallback;
|
|
2796
|
+
options = {};
|
|
2797
|
+
}
|
|
2798
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2799
|
+
const parameters = {
|
|
2800
|
+
options: Object.assign({
|
|
2801
|
+
url: (rootUrl + '/v1beta/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
|
|
2802
|
+
method: 'GET',
|
|
2803
|
+
}, options),
|
|
2804
|
+
params,
|
|
2805
|
+
requiredParams: ['name'],
|
|
2806
|
+
pathParams: ['name'],
|
|
2807
|
+
context: this.context,
|
|
2808
|
+
};
|
|
2809
|
+
if (callback) {
|
|
2810
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2811
|
+
}
|
|
2812
|
+
else {
|
|
2813
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2814
|
+
}
|
|
2815
|
+
}
|
|
2816
|
+
}
|
|
2817
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Collections$Operations = Resource$Projects$Locations$Collections$Operations;
|
|
2818
|
+
class Resource$Projects$Locations$Datastores {
|
|
2819
|
+
constructor(context) {
|
|
2820
|
+
this.context = context;
|
|
2821
|
+
this.branches = new Resource$Projects$Locations$Datastores$Branches(this.context);
|
|
2822
|
+
this.conversations =
|
|
2823
|
+
new Resource$Projects$Locations$Datastores$Conversations(this.context);
|
|
2824
|
+
this.models = new Resource$Projects$Locations$Datastores$Models(this.context);
|
|
2825
|
+
this.operations = new Resource$Projects$Locations$Datastores$Operations(this.context);
|
|
2826
|
+
this.schemas = new Resource$Projects$Locations$Datastores$Schemas(this.context);
|
|
2827
|
+
this.servingConfigs =
|
|
2828
|
+
new Resource$Projects$Locations$Datastores$Servingconfigs(this.context);
|
|
2829
|
+
this.siteSearchEngine =
|
|
2830
|
+
new Resource$Projects$Locations$Datastores$Sitesearchengine(this.context);
|
|
2831
|
+
this.suggestionDenyListEntries =
|
|
2832
|
+
new Resource$Projects$Locations$Datastores$Suggestiondenylistentries(this.context);
|
|
2833
|
+
this.userEvents = new Resource$Projects$Locations$Datastores$Userevents(this.context);
|
|
2834
|
+
}
|
|
2835
|
+
completeQuery(paramsOrCallback, optionsOrCallback, callback) {
|
|
2836
|
+
let params = (paramsOrCallback ||
|
|
2837
|
+
{});
|
|
2838
|
+
let options = (optionsOrCallback || {});
|
|
2839
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2840
|
+
callback = paramsOrCallback;
|
|
2841
|
+
params =
|
|
2842
|
+
{};
|
|
2843
|
+
options = {};
|
|
2844
|
+
}
|
|
2845
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2846
|
+
callback = optionsOrCallback;
|
|
2847
|
+
options = {};
|
|
2848
|
+
}
|
|
2849
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2850
|
+
const parameters = {
|
|
2851
|
+
options: Object.assign({
|
|
2852
|
+
url: (rootUrl + '/v1beta/{+dataStore}:completeQuery').replace(/([^:]\/)\/+/g, '$1'),
|
|
2853
|
+
method: 'GET',
|
|
2854
|
+
}, options),
|
|
2855
|
+
params,
|
|
2856
|
+
requiredParams: ['dataStore'],
|
|
2857
|
+
pathParams: ['dataStore'],
|
|
2858
|
+
context: this.context,
|
|
2859
|
+
};
|
|
2860
|
+
if (callback) {
|
|
2861
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2862
|
+
}
|
|
2863
|
+
else {
|
|
2864
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2865
|
+
}
|
|
2866
|
+
}
|
|
2867
|
+
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
2868
|
+
let params = (paramsOrCallback ||
|
|
2869
|
+
{});
|
|
2870
|
+
let options = (optionsOrCallback || {});
|
|
2871
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2872
|
+
callback = paramsOrCallback;
|
|
2873
|
+
params = {};
|
|
2874
|
+
options = {};
|
|
2875
|
+
}
|
|
2876
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2877
|
+
callback = optionsOrCallback;
|
|
2878
|
+
options = {};
|
|
2879
|
+
}
|
|
2880
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2881
|
+
const parameters = {
|
|
2882
|
+
options: Object.assign({
|
|
2883
|
+
url: (rootUrl + '/v1beta/{+parent}/dataStores').replace(/([^:]\/)\/+/g, '$1'),
|
|
2884
|
+
method: 'POST',
|
|
2885
|
+
}, options),
|
|
2886
|
+
params,
|
|
2887
|
+
requiredParams: ['parent'],
|
|
2888
|
+
pathParams: ['parent'],
|
|
2889
|
+
context: this.context,
|
|
2890
|
+
};
|
|
2891
|
+
if (callback) {
|
|
2892
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2893
|
+
}
|
|
2894
|
+
else {
|
|
2895
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2896
|
+
}
|
|
2897
|
+
}
|
|
2898
|
+
delete(paramsOrCallback, optionsOrCallback, callback) {
|
|
2899
|
+
let params = (paramsOrCallback ||
|
|
2900
|
+
{});
|
|
2901
|
+
let options = (optionsOrCallback || {});
|
|
2902
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2903
|
+
callback = paramsOrCallback;
|
|
2904
|
+
params = {};
|
|
2905
|
+
options = {};
|
|
2906
|
+
}
|
|
2907
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2908
|
+
callback = optionsOrCallback;
|
|
2909
|
+
options = {};
|
|
2910
|
+
}
|
|
2911
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2912
|
+
const parameters = {
|
|
2913
|
+
options: Object.assign({
|
|
2914
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2915
|
+
method: 'DELETE',
|
|
2916
|
+
}, options),
|
|
2917
|
+
params,
|
|
2918
|
+
requiredParams: ['name'],
|
|
2919
|
+
pathParams: ['name'],
|
|
2920
|
+
context: this.context,
|
|
2921
|
+
};
|
|
2922
|
+
if (callback) {
|
|
2923
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2924
|
+
}
|
|
2925
|
+
else {
|
|
2926
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2927
|
+
}
|
|
2928
|
+
}
|
|
2929
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2930
|
+
let params = (paramsOrCallback ||
|
|
2931
|
+
{});
|
|
2932
|
+
let options = (optionsOrCallback || {});
|
|
2933
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2934
|
+
callback = paramsOrCallback;
|
|
2935
|
+
params = {};
|
|
2936
|
+
options = {};
|
|
2937
|
+
}
|
|
2938
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2939
|
+
callback = optionsOrCallback;
|
|
2940
|
+
options = {};
|
|
2941
|
+
}
|
|
2942
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2943
|
+
const parameters = {
|
|
2944
|
+
options: Object.assign({
|
|
2945
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2946
|
+
method: 'GET',
|
|
2947
|
+
}, options),
|
|
2948
|
+
params,
|
|
2949
|
+
requiredParams: ['name'],
|
|
2950
|
+
pathParams: ['name'],
|
|
2951
|
+
context: this.context,
|
|
2952
|
+
};
|
|
2953
|
+
if (callback) {
|
|
2954
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2955
|
+
}
|
|
2956
|
+
else {
|
|
2957
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2958
|
+
}
|
|
2959
|
+
}
|
|
2960
|
+
getSiteSearchEngine(paramsOrCallback, optionsOrCallback, callback) {
|
|
2961
|
+
let params = (paramsOrCallback ||
|
|
2962
|
+
{});
|
|
2963
|
+
let options = (optionsOrCallback || {});
|
|
2964
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2965
|
+
callback = paramsOrCallback;
|
|
2966
|
+
params =
|
|
2967
|
+
{};
|
|
2968
|
+
options = {};
|
|
2969
|
+
}
|
|
2970
|
+
if (typeof optionsOrCallback === 'function') {
|
|
2971
|
+
callback = optionsOrCallback;
|
|
2972
|
+
options = {};
|
|
2973
|
+
}
|
|
2974
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2975
|
+
const parameters = {
|
|
2976
|
+
options: Object.assign({
|
|
2977
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2978
|
+
method: 'GET',
|
|
2979
|
+
}, options),
|
|
2980
|
+
params,
|
|
2981
|
+
requiredParams: ['name'],
|
|
2982
|
+
pathParams: ['name'],
|
|
2983
|
+
context: this.context,
|
|
2984
|
+
};
|
|
2985
|
+
if (callback) {
|
|
2986
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
2987
|
+
}
|
|
2988
|
+
else {
|
|
2989
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2990
|
+
}
|
|
2991
|
+
}
|
|
2992
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
2993
|
+
let params = (paramsOrCallback ||
|
|
2994
|
+
{});
|
|
2995
|
+
let options = (optionsOrCallback || {});
|
|
2996
|
+
if (typeof paramsOrCallback === 'function') {
|
|
2997
|
+
callback = paramsOrCallback;
|
|
2998
|
+
params = {};
|
|
2999
|
+
options = {};
|
|
3000
|
+
}
|
|
3001
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3002
|
+
callback = optionsOrCallback;
|
|
3003
|
+
options = {};
|
|
3004
|
+
}
|
|
3005
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3006
|
+
const parameters = {
|
|
3007
|
+
options: Object.assign({
|
|
3008
|
+
url: (rootUrl + '/v1beta/{+parent}/dataStores').replace(/([^:]\/)\/+/g, '$1'),
|
|
3009
|
+
method: 'GET',
|
|
3010
|
+
}, options),
|
|
3011
|
+
params,
|
|
3012
|
+
requiredParams: ['parent'],
|
|
3013
|
+
pathParams: ['parent'],
|
|
3014
|
+
context: this.context,
|
|
3015
|
+
};
|
|
3016
|
+
if (callback) {
|
|
3017
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3018
|
+
}
|
|
3019
|
+
else {
|
|
3020
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3021
|
+
}
|
|
3022
|
+
}
|
|
3023
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
3024
|
+
let params = (paramsOrCallback ||
|
|
3025
|
+
{});
|
|
3026
|
+
let options = (optionsOrCallback || {});
|
|
3027
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3028
|
+
callback = paramsOrCallback;
|
|
3029
|
+
params = {};
|
|
3030
|
+
options = {};
|
|
3031
|
+
}
|
|
3032
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3033
|
+
callback = optionsOrCallback;
|
|
3034
|
+
options = {};
|
|
3035
|
+
}
|
|
3036
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3037
|
+
const parameters = {
|
|
3038
|
+
options: Object.assign({
|
|
3039
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3040
|
+
method: 'PATCH',
|
|
3041
|
+
}, options),
|
|
3042
|
+
params,
|
|
3043
|
+
requiredParams: ['name'],
|
|
3044
|
+
pathParams: ['name'],
|
|
3045
|
+
context: this.context,
|
|
3046
|
+
};
|
|
3047
|
+
if (callback) {
|
|
3048
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3049
|
+
}
|
|
3050
|
+
else {
|
|
3051
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3052
|
+
}
|
|
3053
|
+
}
|
|
3054
|
+
}
|
|
3055
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores = Resource$Projects$Locations$Datastores;
|
|
3056
|
+
class Resource$Projects$Locations$Datastores$Branches {
|
|
3057
|
+
constructor(context) {
|
|
3058
|
+
this.context = context;
|
|
3059
|
+
this.documents =
|
|
3060
|
+
new Resource$Projects$Locations$Datastores$Branches$Documents(this.context);
|
|
3061
|
+
this.operations =
|
|
3062
|
+
new Resource$Projects$Locations$Datastores$Branches$Operations(this.context);
|
|
3063
|
+
}
|
|
3064
|
+
}
|
|
3065
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Branches = Resource$Projects$Locations$Datastores$Branches;
|
|
3066
|
+
class Resource$Projects$Locations$Datastores$Branches$Documents {
|
|
3067
|
+
constructor(context) {
|
|
3068
|
+
this.context = context;
|
|
3069
|
+
}
|
|
3070
|
+
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
3071
|
+
let params = (paramsOrCallback ||
|
|
3072
|
+
{});
|
|
3073
|
+
let options = (optionsOrCallback || {});
|
|
3074
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3075
|
+
callback = paramsOrCallback;
|
|
3076
|
+
params =
|
|
3077
|
+
{};
|
|
3078
|
+
options = {};
|
|
3079
|
+
}
|
|
3080
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3081
|
+
callback = optionsOrCallback;
|
|
3082
|
+
options = {};
|
|
3083
|
+
}
|
|
3084
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3085
|
+
const parameters = {
|
|
3086
|
+
options: Object.assign({
|
|
3087
|
+
url: (rootUrl + '/v1beta/{+parent}/documents').replace(/([^:]\/)\/+/g, '$1'),
|
|
3088
|
+
method: 'POST',
|
|
3089
|
+
}, options),
|
|
3090
|
+
params,
|
|
3091
|
+
requiredParams: ['parent'],
|
|
3092
|
+
pathParams: ['parent'],
|
|
3093
|
+
context: this.context,
|
|
3094
|
+
};
|
|
3095
|
+
if (callback) {
|
|
3096
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3097
|
+
}
|
|
3098
|
+
else {
|
|
3099
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3100
|
+
}
|
|
3101
|
+
}
|
|
3102
|
+
delete(paramsOrCallback, optionsOrCallback, callback) {
|
|
3103
|
+
let params = (paramsOrCallback ||
|
|
3104
|
+
{});
|
|
3105
|
+
let options = (optionsOrCallback || {});
|
|
3106
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3107
|
+
callback = paramsOrCallback;
|
|
3108
|
+
params =
|
|
3109
|
+
{};
|
|
3110
|
+
options = {};
|
|
3111
|
+
}
|
|
3112
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3113
|
+
callback = optionsOrCallback;
|
|
3114
|
+
options = {};
|
|
3115
|
+
}
|
|
3116
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3117
|
+
const parameters = {
|
|
3118
|
+
options: Object.assign({
|
|
3119
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3120
|
+
method: 'DELETE',
|
|
3121
|
+
}, options),
|
|
3122
|
+
params,
|
|
3123
|
+
requiredParams: ['name'],
|
|
3124
|
+
pathParams: ['name'],
|
|
3125
|
+
context: this.context,
|
|
3126
|
+
};
|
|
3127
|
+
if (callback) {
|
|
3128
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3129
|
+
}
|
|
3130
|
+
else {
|
|
3131
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3132
|
+
}
|
|
3133
|
+
}
|
|
3134
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
3135
|
+
let params = (paramsOrCallback ||
|
|
3136
|
+
{});
|
|
3137
|
+
let options = (optionsOrCallback || {});
|
|
3138
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3139
|
+
callback = paramsOrCallback;
|
|
3140
|
+
params =
|
|
3141
|
+
{};
|
|
3142
|
+
options = {};
|
|
3143
|
+
}
|
|
3144
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3145
|
+
callback = optionsOrCallback;
|
|
3146
|
+
options = {};
|
|
3147
|
+
}
|
|
3148
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3149
|
+
const parameters = {
|
|
3150
|
+
options: Object.assign({
|
|
3151
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3152
|
+
method: 'GET',
|
|
3153
|
+
}, options),
|
|
3154
|
+
params,
|
|
3155
|
+
requiredParams: ['name'],
|
|
3156
|
+
pathParams: ['name'],
|
|
3157
|
+
context: this.context,
|
|
3158
|
+
};
|
|
3159
|
+
if (callback) {
|
|
3160
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3161
|
+
}
|
|
3162
|
+
else {
|
|
3163
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3164
|
+
}
|
|
3165
|
+
}
|
|
3166
|
+
import(paramsOrCallback, optionsOrCallback, callback) {
|
|
3167
|
+
let params = (paramsOrCallback ||
|
|
3168
|
+
{});
|
|
3169
|
+
let options = (optionsOrCallback || {});
|
|
3170
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3171
|
+
callback = paramsOrCallback;
|
|
3172
|
+
params =
|
|
3173
|
+
{};
|
|
3174
|
+
options = {};
|
|
3175
|
+
}
|
|
3176
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3177
|
+
callback = optionsOrCallback;
|
|
3178
|
+
options = {};
|
|
3179
|
+
}
|
|
3180
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3181
|
+
const parameters = {
|
|
3182
|
+
options: Object.assign({
|
|
3183
|
+
url: (rootUrl + '/v1beta/{+parent}/documents:import').replace(/([^:]\/)\/+/g, '$1'),
|
|
3184
|
+
method: 'POST',
|
|
3185
|
+
}, options),
|
|
3186
|
+
params,
|
|
3187
|
+
requiredParams: ['parent'],
|
|
3188
|
+
pathParams: ['parent'],
|
|
3189
|
+
context: this.context,
|
|
3190
|
+
};
|
|
3191
|
+
if (callback) {
|
|
3192
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3193
|
+
}
|
|
3194
|
+
else {
|
|
3195
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3196
|
+
}
|
|
3197
|
+
}
|
|
3198
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
3199
|
+
let params = (paramsOrCallback ||
|
|
3200
|
+
{});
|
|
3201
|
+
let options = (optionsOrCallback || {});
|
|
3202
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3203
|
+
callback = paramsOrCallback;
|
|
3204
|
+
params =
|
|
3205
|
+
{};
|
|
3206
|
+
options = {};
|
|
3207
|
+
}
|
|
3208
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3209
|
+
callback = optionsOrCallback;
|
|
3210
|
+
options = {};
|
|
3211
|
+
}
|
|
3212
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3213
|
+
const parameters = {
|
|
3214
|
+
options: Object.assign({
|
|
3215
|
+
url: (rootUrl + '/v1beta/{+parent}/documents').replace(/([^:]\/)\/+/g, '$1'),
|
|
3216
|
+
method: 'GET',
|
|
3217
|
+
}, options),
|
|
3218
|
+
params,
|
|
3219
|
+
requiredParams: ['parent'],
|
|
3220
|
+
pathParams: ['parent'],
|
|
3221
|
+
context: this.context,
|
|
3222
|
+
};
|
|
3223
|
+
if (callback) {
|
|
3224
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3225
|
+
}
|
|
3226
|
+
else {
|
|
3227
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3228
|
+
}
|
|
3229
|
+
}
|
|
3230
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
3231
|
+
let params = (paramsOrCallback ||
|
|
3232
|
+
{});
|
|
3233
|
+
let options = (optionsOrCallback || {});
|
|
3234
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3235
|
+
callback = paramsOrCallback;
|
|
3236
|
+
params =
|
|
3237
|
+
{};
|
|
3238
|
+
options = {};
|
|
3239
|
+
}
|
|
3240
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3241
|
+
callback = optionsOrCallback;
|
|
3242
|
+
options = {};
|
|
3243
|
+
}
|
|
3244
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3245
|
+
const parameters = {
|
|
3246
|
+
options: Object.assign({
|
|
3247
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3248
|
+
method: 'PATCH',
|
|
3249
|
+
}, options),
|
|
3250
|
+
params,
|
|
3251
|
+
requiredParams: ['name'],
|
|
3252
|
+
pathParams: ['name'],
|
|
3253
|
+
context: this.context,
|
|
3254
|
+
};
|
|
3255
|
+
if (callback) {
|
|
3256
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3257
|
+
}
|
|
3258
|
+
else {
|
|
3259
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3260
|
+
}
|
|
3261
|
+
}
|
|
3262
|
+
purge(paramsOrCallback, optionsOrCallback, callback) {
|
|
3263
|
+
let params = (paramsOrCallback ||
|
|
3264
|
+
{});
|
|
3265
|
+
let options = (optionsOrCallback || {});
|
|
3266
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3267
|
+
callback = paramsOrCallback;
|
|
3268
|
+
params =
|
|
3269
|
+
{};
|
|
3270
|
+
options = {};
|
|
3271
|
+
}
|
|
3272
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3273
|
+
callback = optionsOrCallback;
|
|
3274
|
+
options = {};
|
|
3275
|
+
}
|
|
3276
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3277
|
+
const parameters = {
|
|
3278
|
+
options: Object.assign({
|
|
3279
|
+
url: (rootUrl + '/v1beta/{+parent}/documents:purge').replace(/([^:]\/)\/+/g, '$1'),
|
|
3280
|
+
method: 'POST',
|
|
3281
|
+
}, options),
|
|
3282
|
+
params,
|
|
3283
|
+
requiredParams: ['parent'],
|
|
3284
|
+
pathParams: ['parent'],
|
|
3285
|
+
context: this.context,
|
|
3286
|
+
};
|
|
3287
|
+
if (callback) {
|
|
3288
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3289
|
+
}
|
|
3290
|
+
else {
|
|
3291
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3292
|
+
}
|
|
3293
|
+
}
|
|
3294
|
+
}
|
|
3295
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Branches$Documents = Resource$Projects$Locations$Datastores$Branches$Documents;
|
|
3296
|
+
class Resource$Projects$Locations$Datastores$Branches$Operations {
|
|
3297
|
+
constructor(context) {
|
|
3298
|
+
this.context = context;
|
|
3299
|
+
}
|
|
3300
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
3301
|
+
let params = (paramsOrCallback ||
|
|
3302
|
+
{});
|
|
3303
|
+
let options = (optionsOrCallback || {});
|
|
3304
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3305
|
+
callback = paramsOrCallback;
|
|
3306
|
+
params =
|
|
3307
|
+
{};
|
|
3308
|
+
options = {};
|
|
3309
|
+
}
|
|
3310
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3311
|
+
callback = optionsOrCallback;
|
|
3312
|
+
options = {};
|
|
3313
|
+
}
|
|
3314
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3315
|
+
const parameters = {
|
|
3316
|
+
options: Object.assign({
|
|
3317
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3318
|
+
method: 'GET',
|
|
3319
|
+
}, options),
|
|
3320
|
+
params,
|
|
3321
|
+
requiredParams: ['name'],
|
|
3322
|
+
pathParams: ['name'],
|
|
3323
|
+
context: this.context,
|
|
3324
|
+
};
|
|
3325
|
+
if (callback) {
|
|
3326
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3327
|
+
}
|
|
3328
|
+
else {
|
|
3329
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3330
|
+
}
|
|
3331
|
+
}
|
|
3332
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
3333
|
+
let params = (paramsOrCallback ||
|
|
3334
|
+
{});
|
|
3335
|
+
let options = (optionsOrCallback || {});
|
|
3336
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3337
|
+
callback = paramsOrCallback;
|
|
3338
|
+
params =
|
|
3339
|
+
{};
|
|
3340
|
+
options = {};
|
|
3341
|
+
}
|
|
3342
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3343
|
+
callback = optionsOrCallback;
|
|
3344
|
+
options = {};
|
|
3345
|
+
}
|
|
3346
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3347
|
+
const parameters = {
|
|
3348
|
+
options: Object.assign({
|
|
3349
|
+
url: (rootUrl + '/v1beta/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
|
|
3350
|
+
method: 'GET',
|
|
3351
|
+
}, options),
|
|
3352
|
+
params,
|
|
3353
|
+
requiredParams: ['name'],
|
|
3354
|
+
pathParams: ['name'],
|
|
3355
|
+
context: this.context,
|
|
3356
|
+
};
|
|
3357
|
+
if (callback) {
|
|
3358
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3359
|
+
}
|
|
3360
|
+
else {
|
|
3361
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3362
|
+
}
|
|
3363
|
+
}
|
|
3364
|
+
}
|
|
3365
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Branches$Operations = Resource$Projects$Locations$Datastores$Branches$Operations;
|
|
3366
|
+
class Resource$Projects$Locations$Datastores$Conversations {
|
|
3367
|
+
constructor(context) {
|
|
3368
|
+
this.context = context;
|
|
3369
|
+
}
|
|
3370
|
+
converse(paramsOrCallback, optionsOrCallback, callback) {
|
|
3371
|
+
let params = (paramsOrCallback ||
|
|
3372
|
+
{});
|
|
3373
|
+
let options = (optionsOrCallback || {});
|
|
3374
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3375
|
+
callback = paramsOrCallback;
|
|
3376
|
+
params =
|
|
3377
|
+
{};
|
|
3378
|
+
options = {};
|
|
3379
|
+
}
|
|
3380
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3381
|
+
callback = optionsOrCallback;
|
|
3382
|
+
options = {};
|
|
3383
|
+
}
|
|
3384
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3385
|
+
const parameters = {
|
|
3386
|
+
options: Object.assign({
|
|
3387
|
+
url: (rootUrl + '/v1beta/{+name}:converse').replace(/([^:]\/)\/+/g, '$1'),
|
|
3388
|
+
method: 'POST',
|
|
3389
|
+
}, options),
|
|
3390
|
+
params,
|
|
3391
|
+
requiredParams: ['name'],
|
|
3392
|
+
pathParams: ['name'],
|
|
3393
|
+
context: this.context,
|
|
3394
|
+
};
|
|
3395
|
+
if (callback) {
|
|
3396
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3397
|
+
}
|
|
3398
|
+
else {
|
|
3399
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3400
|
+
}
|
|
3401
|
+
}
|
|
3402
|
+
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
3403
|
+
let params = (paramsOrCallback ||
|
|
3404
|
+
{});
|
|
3405
|
+
let options = (optionsOrCallback || {});
|
|
3406
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3407
|
+
callback = paramsOrCallback;
|
|
3408
|
+
params =
|
|
3409
|
+
{};
|
|
3410
|
+
options = {};
|
|
3411
|
+
}
|
|
3412
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3413
|
+
callback = optionsOrCallback;
|
|
3414
|
+
options = {};
|
|
3415
|
+
}
|
|
3416
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3417
|
+
const parameters = {
|
|
3418
|
+
options: Object.assign({
|
|
3419
|
+
url: (rootUrl + '/v1beta/{+parent}/conversations').replace(/([^:]\/)\/+/g, '$1'),
|
|
3420
|
+
method: 'POST',
|
|
3421
|
+
}, options),
|
|
3422
|
+
params,
|
|
3423
|
+
requiredParams: ['parent'],
|
|
3424
|
+
pathParams: ['parent'],
|
|
3425
|
+
context: this.context,
|
|
3426
|
+
};
|
|
3427
|
+
if (callback) {
|
|
3428
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3429
|
+
}
|
|
3430
|
+
else {
|
|
3431
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3432
|
+
}
|
|
3433
|
+
}
|
|
3434
|
+
delete(paramsOrCallback, optionsOrCallback, callback) {
|
|
3435
|
+
let params = (paramsOrCallback ||
|
|
3436
|
+
{});
|
|
3437
|
+
let options = (optionsOrCallback || {});
|
|
3438
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3439
|
+
callback = paramsOrCallback;
|
|
3440
|
+
params =
|
|
3441
|
+
{};
|
|
3442
|
+
options = {};
|
|
3443
|
+
}
|
|
3444
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3445
|
+
callback = optionsOrCallback;
|
|
3446
|
+
options = {};
|
|
3447
|
+
}
|
|
3448
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3449
|
+
const parameters = {
|
|
3450
|
+
options: Object.assign({
|
|
3451
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3452
|
+
method: 'DELETE',
|
|
3453
|
+
}, options),
|
|
3454
|
+
params,
|
|
3455
|
+
requiredParams: ['name'],
|
|
3456
|
+
pathParams: ['name'],
|
|
3457
|
+
context: this.context,
|
|
3458
|
+
};
|
|
3459
|
+
if (callback) {
|
|
3460
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3461
|
+
}
|
|
3462
|
+
else {
|
|
3463
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3464
|
+
}
|
|
3465
|
+
}
|
|
3466
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
3467
|
+
let params = (paramsOrCallback ||
|
|
3468
|
+
{});
|
|
3469
|
+
let options = (optionsOrCallback || {});
|
|
3470
|
+
if (typeof paramsOrCallback === 'function') {
|
|
3471
|
+
callback = paramsOrCallback;
|
|
3472
|
+
params =
|
|
3473
|
+
{};
|
|
3474
|
+
options = {};
|
|
3475
|
+
}
|
|
3476
|
+
if (typeof optionsOrCallback === 'function') {
|
|
3477
|
+
callback = optionsOrCallback;
|
|
3478
|
+
options = {};
|
|
3479
|
+
}
|
|
3480
|
+
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
3481
|
+
const parameters = {
|
|
3482
|
+
options: Object.assign({
|
|
3483
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3484
|
+
method: 'GET',
|
|
3485
|
+
}, options),
|
|
3486
|
+
params,
|
|
3487
|
+
requiredParams: ['name'],
|
|
3488
|
+
pathParams: ['name'],
|
|
3489
|
+
context: this.context,
|
|
3490
|
+
};
|
|
3491
|
+
if (callback) {
|
|
3492
|
+
(0, googleapis_common_1.createAPIRequest)(parameters, callback);
|
|
3493
|
+
}
|
|
3494
|
+
else {
|
|
3495
|
+
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
3496
|
+
}
|
|
1861
3497
|
}
|
|
1862
|
-
|
|
3498
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
1863
3499
|
let params = (paramsOrCallback ||
|
|
1864
3500
|
{});
|
|
1865
3501
|
let options = (optionsOrCallback || {});
|
|
@@ -1876,12 +3512,12 @@ var discoveryengine_v1beta;
|
|
|
1876
3512
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1877
3513
|
const parameters = {
|
|
1878
3514
|
options: Object.assign({
|
|
1879
|
-
url: (rootUrl + '/v1beta/{+
|
|
3515
|
+
url: (rootUrl + '/v1beta/{+parent}/conversations').replace(/([^:]\/)\/+/g, '$1'),
|
|
1880
3516
|
method: 'GET',
|
|
1881
3517
|
}, options),
|
|
1882
3518
|
params,
|
|
1883
|
-
requiredParams: ['
|
|
1884
|
-
pathParams: ['
|
|
3519
|
+
requiredParams: ['parent'],
|
|
3520
|
+
pathParams: ['parent'],
|
|
1885
3521
|
context: this.context,
|
|
1886
3522
|
};
|
|
1887
3523
|
if (callback) {
|
|
@@ -1891,23 +3527,7 @@ var discoveryengine_v1beta;
|
|
|
1891
3527
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1892
3528
|
}
|
|
1893
3529
|
}
|
|
1894
|
-
|
|
1895
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores = Resource$Projects$Locations$Datastores;
|
|
1896
|
-
class Resource$Projects$Locations$Datastores$Branches {
|
|
1897
|
-
constructor(context) {
|
|
1898
|
-
this.context = context;
|
|
1899
|
-
this.documents =
|
|
1900
|
-
new Resource$Projects$Locations$Datastores$Branches$Documents(this.context);
|
|
1901
|
-
this.operations =
|
|
1902
|
-
new Resource$Projects$Locations$Datastores$Branches$Operations(this.context);
|
|
1903
|
-
}
|
|
1904
|
-
}
|
|
1905
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Branches = Resource$Projects$Locations$Datastores$Branches;
|
|
1906
|
-
class Resource$Projects$Locations$Datastores$Branches$Documents {
|
|
1907
|
-
constructor(context) {
|
|
1908
|
-
this.context = context;
|
|
1909
|
-
}
|
|
1910
|
-
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
3530
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
1911
3531
|
let params = (paramsOrCallback ||
|
|
1912
3532
|
{});
|
|
1913
3533
|
let options = (optionsOrCallback || {});
|
|
@@ -1924,12 +3544,12 @@ var discoveryengine_v1beta;
|
|
|
1924
3544
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1925
3545
|
const parameters = {
|
|
1926
3546
|
options: Object.assign({
|
|
1927
|
-
url: (rootUrl + '/v1beta/{+
|
|
1928
|
-
method: '
|
|
3547
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3548
|
+
method: 'PATCH',
|
|
1929
3549
|
}, options),
|
|
1930
3550
|
params,
|
|
1931
|
-
requiredParams: ['
|
|
1932
|
-
pathParams: ['
|
|
3551
|
+
requiredParams: ['name'],
|
|
3552
|
+
pathParams: ['name'],
|
|
1933
3553
|
context: this.context,
|
|
1934
3554
|
};
|
|
1935
3555
|
if (callback) {
|
|
@@ -1939,7 +3559,21 @@ var discoveryengine_v1beta;
|
|
|
1939
3559
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1940
3560
|
}
|
|
1941
3561
|
}
|
|
1942
|
-
|
|
3562
|
+
}
|
|
3563
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Conversations = Resource$Projects$Locations$Datastores$Conversations;
|
|
3564
|
+
class Resource$Projects$Locations$Datastores$Models {
|
|
3565
|
+
constructor(context) {
|
|
3566
|
+
this.context = context;
|
|
3567
|
+
this.operations =
|
|
3568
|
+
new Resource$Projects$Locations$Datastores$Models$Operations(this.context);
|
|
3569
|
+
}
|
|
3570
|
+
}
|
|
3571
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Models = Resource$Projects$Locations$Datastores$Models;
|
|
3572
|
+
class Resource$Projects$Locations$Datastores$Models$Operations {
|
|
3573
|
+
constructor(context) {
|
|
3574
|
+
this.context = context;
|
|
3575
|
+
}
|
|
3576
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
1943
3577
|
let params = (paramsOrCallback ||
|
|
1944
3578
|
{});
|
|
1945
3579
|
let options = (optionsOrCallback || {});
|
|
@@ -1957,7 +3591,7 @@ var discoveryengine_v1beta;
|
|
|
1957
3591
|
const parameters = {
|
|
1958
3592
|
options: Object.assign({
|
|
1959
3593
|
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
1960
|
-
method: '
|
|
3594
|
+
method: 'GET',
|
|
1961
3595
|
}, options),
|
|
1962
3596
|
params,
|
|
1963
3597
|
requiredParams: ['name'],
|
|
@@ -1971,7 +3605,7 @@ var discoveryengine_v1beta;
|
|
|
1971
3605
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
1972
3606
|
}
|
|
1973
3607
|
}
|
|
1974
|
-
|
|
3608
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
1975
3609
|
let params = (paramsOrCallback ||
|
|
1976
3610
|
{});
|
|
1977
3611
|
let options = (optionsOrCallback || {});
|
|
@@ -1988,7 +3622,7 @@ var discoveryengine_v1beta;
|
|
|
1988
3622
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
1989
3623
|
const parameters = {
|
|
1990
3624
|
options: Object.assign({
|
|
1991
|
-
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3625
|
+
url: (rootUrl + '/v1beta/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
|
|
1992
3626
|
method: 'GET',
|
|
1993
3627
|
}, options),
|
|
1994
3628
|
params,
|
|
@@ -2003,7 +3637,13 @@ var discoveryengine_v1beta;
|
|
|
2003
3637
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2004
3638
|
}
|
|
2005
3639
|
}
|
|
2006
|
-
|
|
3640
|
+
}
|
|
3641
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Models$Operations = Resource$Projects$Locations$Datastores$Models$Operations;
|
|
3642
|
+
class Resource$Projects$Locations$Datastores$Operations {
|
|
3643
|
+
constructor(context) {
|
|
3644
|
+
this.context = context;
|
|
3645
|
+
}
|
|
3646
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2007
3647
|
let params = (paramsOrCallback ||
|
|
2008
3648
|
{});
|
|
2009
3649
|
let options = (optionsOrCallback || {});
|
|
@@ -2020,12 +3660,12 @@ var discoveryengine_v1beta;
|
|
|
2020
3660
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2021
3661
|
const parameters = {
|
|
2022
3662
|
options: Object.assign({
|
|
2023
|
-
url: (rootUrl + '/v1beta/{+
|
|
2024
|
-
method: '
|
|
3663
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3664
|
+
method: 'GET',
|
|
2025
3665
|
}, options),
|
|
2026
3666
|
params,
|
|
2027
|
-
requiredParams: ['
|
|
2028
|
-
pathParams: ['
|
|
3667
|
+
requiredParams: ['name'],
|
|
3668
|
+
pathParams: ['name'],
|
|
2029
3669
|
context: this.context,
|
|
2030
3670
|
};
|
|
2031
3671
|
if (callback) {
|
|
@@ -2052,12 +3692,12 @@ var discoveryengine_v1beta;
|
|
|
2052
3692
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2053
3693
|
const parameters = {
|
|
2054
3694
|
options: Object.assign({
|
|
2055
|
-
url: (rootUrl + '/v1beta/{+
|
|
3695
|
+
url: (rootUrl + '/v1beta/{+name}/operations').replace(/([^:]\/)\/+/g, '$1'),
|
|
2056
3696
|
method: 'GET',
|
|
2057
3697
|
}, options),
|
|
2058
3698
|
params,
|
|
2059
|
-
requiredParams: ['
|
|
2060
|
-
pathParams: ['
|
|
3699
|
+
requiredParams: ['name'],
|
|
3700
|
+
pathParams: ['name'],
|
|
2061
3701
|
context: this.context,
|
|
2062
3702
|
};
|
|
2063
3703
|
if (callback) {
|
|
@@ -2067,7 +3707,13 @@ var discoveryengine_v1beta;
|
|
|
2067
3707
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2068
3708
|
}
|
|
2069
3709
|
}
|
|
2070
|
-
|
|
3710
|
+
}
|
|
3711
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Operations = Resource$Projects$Locations$Datastores$Operations;
|
|
3712
|
+
class Resource$Projects$Locations$Datastores$Schemas {
|
|
3713
|
+
constructor(context) {
|
|
3714
|
+
this.context = context;
|
|
3715
|
+
}
|
|
3716
|
+
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
2071
3717
|
let params = (paramsOrCallback ||
|
|
2072
3718
|
{});
|
|
2073
3719
|
let options = (optionsOrCallback || {});
|
|
@@ -2084,12 +3730,12 @@ var discoveryengine_v1beta;
|
|
|
2084
3730
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2085
3731
|
const parameters = {
|
|
2086
3732
|
options: Object.assign({
|
|
2087
|
-
url: (rootUrl + '/v1beta/{+
|
|
2088
|
-
method: '
|
|
3733
|
+
url: (rootUrl + '/v1beta/{+parent}/schemas').replace(/([^:]\/)\/+/g, '$1'),
|
|
3734
|
+
method: 'POST',
|
|
2089
3735
|
}, options),
|
|
2090
3736
|
params,
|
|
2091
|
-
requiredParams: ['
|
|
2092
|
-
pathParams: ['
|
|
3737
|
+
requiredParams: ['parent'],
|
|
3738
|
+
pathParams: ['parent'],
|
|
2093
3739
|
context: this.context,
|
|
2094
3740
|
};
|
|
2095
3741
|
if (callback) {
|
|
@@ -2099,7 +3745,7 @@ var discoveryengine_v1beta;
|
|
|
2099
3745
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2100
3746
|
}
|
|
2101
3747
|
}
|
|
2102
|
-
|
|
3748
|
+
delete(paramsOrCallback, optionsOrCallback, callback) {
|
|
2103
3749
|
let params = (paramsOrCallback ||
|
|
2104
3750
|
{});
|
|
2105
3751
|
let options = (optionsOrCallback || {});
|
|
@@ -2116,12 +3762,12 @@ var discoveryengine_v1beta;
|
|
|
2116
3762
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2117
3763
|
const parameters = {
|
|
2118
3764
|
options: Object.assign({
|
|
2119
|
-
url: (rootUrl + '/v1beta/{+
|
|
2120
|
-
method: '
|
|
3765
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3766
|
+
method: 'DELETE',
|
|
2121
3767
|
}, options),
|
|
2122
3768
|
params,
|
|
2123
|
-
requiredParams: ['
|
|
2124
|
-
pathParams: ['
|
|
3769
|
+
requiredParams: ['name'],
|
|
3770
|
+
pathParams: ['name'],
|
|
2125
3771
|
context: this.context,
|
|
2126
3772
|
};
|
|
2127
3773
|
if (callback) {
|
|
@@ -2131,12 +3777,6 @@ var discoveryengine_v1beta;
|
|
|
2131
3777
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2132
3778
|
}
|
|
2133
3779
|
}
|
|
2134
|
-
}
|
|
2135
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Branches$Documents = Resource$Projects$Locations$Datastores$Branches$Documents;
|
|
2136
|
-
class Resource$Projects$Locations$Datastores$Branches$Operations {
|
|
2137
|
-
constructor(context) {
|
|
2138
|
-
this.context = context;
|
|
2139
|
-
}
|
|
2140
3780
|
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2141
3781
|
let params = (paramsOrCallback ||
|
|
2142
3782
|
{});
|
|
@@ -2186,12 +3826,12 @@ var discoveryengine_v1beta;
|
|
|
2186
3826
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2187
3827
|
const parameters = {
|
|
2188
3828
|
options: Object.assign({
|
|
2189
|
-
url: (rootUrl + '/v1beta/{+
|
|
3829
|
+
url: (rootUrl + '/v1beta/{+parent}/schemas').replace(/([^:]\/)\/+/g, '$1'),
|
|
2190
3830
|
method: 'GET',
|
|
2191
3831
|
}, options),
|
|
2192
3832
|
params,
|
|
2193
|
-
requiredParams: ['
|
|
2194
|
-
pathParams: ['
|
|
3833
|
+
requiredParams: ['parent'],
|
|
3834
|
+
pathParams: ['parent'],
|
|
2195
3835
|
context: this.context,
|
|
2196
3836
|
};
|
|
2197
3837
|
if (callback) {
|
|
@@ -2201,13 +3841,7 @@ var discoveryengine_v1beta;
|
|
|
2201
3841
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2202
3842
|
}
|
|
2203
3843
|
}
|
|
2204
|
-
|
|
2205
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Branches$Operations = Resource$Projects$Locations$Datastores$Branches$Operations;
|
|
2206
|
-
class Resource$Projects$Locations$Datastores$Conversations {
|
|
2207
|
-
constructor(context) {
|
|
2208
|
-
this.context = context;
|
|
2209
|
-
}
|
|
2210
|
-
converse(paramsOrCallback, optionsOrCallback, callback) {
|
|
3844
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
2211
3845
|
let params = (paramsOrCallback ||
|
|
2212
3846
|
{});
|
|
2213
3847
|
let options = (optionsOrCallback || {});
|
|
@@ -2224,8 +3858,8 @@ var discoveryengine_v1beta;
|
|
|
2224
3858
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2225
3859
|
const parameters = {
|
|
2226
3860
|
options: Object.assign({
|
|
2227
|
-
url: (rootUrl + '/v1beta/{+name}
|
|
2228
|
-
method: '
|
|
3861
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3862
|
+
method: 'PATCH',
|
|
2229
3863
|
}, options),
|
|
2230
3864
|
params,
|
|
2231
3865
|
requiredParams: ['name'],
|
|
@@ -2239,7 +3873,13 @@ var discoveryengine_v1beta;
|
|
|
2239
3873
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2240
3874
|
}
|
|
2241
3875
|
}
|
|
2242
|
-
|
|
3876
|
+
}
|
|
3877
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Schemas = Resource$Projects$Locations$Datastores$Schemas;
|
|
3878
|
+
class Resource$Projects$Locations$Datastores$Servingconfigs {
|
|
3879
|
+
constructor(context) {
|
|
3880
|
+
this.context = context;
|
|
3881
|
+
}
|
|
3882
|
+
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
2243
3883
|
let params = (paramsOrCallback ||
|
|
2244
3884
|
{});
|
|
2245
3885
|
let options = (optionsOrCallback || {});
|
|
@@ -2256,12 +3896,12 @@ var discoveryengine_v1beta;
|
|
|
2256
3896
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2257
3897
|
const parameters = {
|
|
2258
3898
|
options: Object.assign({
|
|
2259
|
-
url: (rootUrl + '/v1beta/{+
|
|
2260
|
-
method: '
|
|
3899
|
+
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
3900
|
+
method: 'GET',
|
|
2261
3901
|
}, options),
|
|
2262
3902
|
params,
|
|
2263
|
-
requiredParams: ['
|
|
2264
|
-
pathParams: ['
|
|
3903
|
+
requiredParams: ['name'],
|
|
3904
|
+
pathParams: ['name'],
|
|
2265
3905
|
context: this.context,
|
|
2266
3906
|
};
|
|
2267
3907
|
if (callback) {
|
|
@@ -2271,7 +3911,7 @@ var discoveryengine_v1beta;
|
|
|
2271
3911
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2272
3912
|
}
|
|
2273
3913
|
}
|
|
2274
|
-
|
|
3914
|
+
list(paramsOrCallback, optionsOrCallback, callback) {
|
|
2275
3915
|
let params = (paramsOrCallback ||
|
|
2276
3916
|
{});
|
|
2277
3917
|
let options = (optionsOrCallback || {});
|
|
@@ -2288,12 +3928,12 @@ var discoveryengine_v1beta;
|
|
|
2288
3928
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2289
3929
|
const parameters = {
|
|
2290
3930
|
options: Object.assign({
|
|
2291
|
-
url: (rootUrl + '/v1beta/{+
|
|
2292
|
-
method: '
|
|
3931
|
+
url: (rootUrl + '/v1beta/{+parent}/servingConfigs').replace(/([^:]\/)\/+/g, '$1'),
|
|
3932
|
+
method: 'GET',
|
|
2293
3933
|
}, options),
|
|
2294
3934
|
params,
|
|
2295
|
-
requiredParams: ['
|
|
2296
|
-
pathParams: ['
|
|
3935
|
+
requiredParams: ['parent'],
|
|
3936
|
+
pathParams: ['parent'],
|
|
2297
3937
|
context: this.context,
|
|
2298
3938
|
};
|
|
2299
3939
|
if (callback) {
|
|
@@ -2303,7 +3943,7 @@ var discoveryengine_v1beta;
|
|
|
2303
3943
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2304
3944
|
}
|
|
2305
3945
|
}
|
|
2306
|
-
|
|
3946
|
+
patch(paramsOrCallback, optionsOrCallback, callback) {
|
|
2307
3947
|
let params = (paramsOrCallback ||
|
|
2308
3948
|
{});
|
|
2309
3949
|
let options = (optionsOrCallback || {});
|
|
@@ -2321,7 +3961,7 @@ var discoveryengine_v1beta;
|
|
|
2321
3961
|
const parameters = {
|
|
2322
3962
|
options: Object.assign({
|
|
2323
3963
|
url: (rootUrl + '/v1beta/{+name}').replace(/([^:]\/)\/+/g, '$1'),
|
|
2324
|
-
method: '
|
|
3964
|
+
method: 'PATCH',
|
|
2325
3965
|
}, options),
|
|
2326
3966
|
params,
|
|
2327
3967
|
requiredParams: ['name'],
|
|
@@ -2335,7 +3975,7 @@ var discoveryengine_v1beta;
|
|
|
2335
3975
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2336
3976
|
}
|
|
2337
3977
|
}
|
|
2338
|
-
|
|
3978
|
+
recommend(paramsOrCallback, optionsOrCallback, callback) {
|
|
2339
3979
|
let params = (paramsOrCallback ||
|
|
2340
3980
|
{});
|
|
2341
3981
|
let options = (optionsOrCallback || {});
|
|
@@ -2352,12 +3992,12 @@ var discoveryengine_v1beta;
|
|
|
2352
3992
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2353
3993
|
const parameters = {
|
|
2354
3994
|
options: Object.assign({
|
|
2355
|
-
url: (rootUrl + '/v1beta/{+
|
|
2356
|
-
method: '
|
|
3995
|
+
url: (rootUrl + '/v1beta/{+servingConfig}:recommend').replace(/([^:]\/)\/+/g, '$1'),
|
|
3996
|
+
method: 'POST',
|
|
2357
3997
|
}, options),
|
|
2358
3998
|
params,
|
|
2359
|
-
requiredParams: ['
|
|
2360
|
-
pathParams: ['
|
|
3999
|
+
requiredParams: ['servingConfig'],
|
|
4000
|
+
pathParams: ['servingConfig'],
|
|
2361
4001
|
context: this.context,
|
|
2362
4002
|
};
|
|
2363
4003
|
if (callback) {
|
|
@@ -2367,7 +4007,7 @@ var discoveryengine_v1beta;
|
|
|
2367
4007
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2368
4008
|
}
|
|
2369
4009
|
}
|
|
2370
|
-
|
|
4010
|
+
search(paramsOrCallback, optionsOrCallback, callback) {
|
|
2371
4011
|
let params = (paramsOrCallback ||
|
|
2372
4012
|
{});
|
|
2373
4013
|
let options = (optionsOrCallback || {});
|
|
@@ -2384,12 +4024,12 @@ var discoveryengine_v1beta;
|
|
|
2384
4024
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2385
4025
|
const parameters = {
|
|
2386
4026
|
options: Object.assign({
|
|
2387
|
-
url: (rootUrl + '/v1beta/{+
|
|
2388
|
-
method: '
|
|
4027
|
+
url: (rootUrl + '/v1beta/{+servingConfig}:search').replace(/([^:]\/)\/+/g, '$1'),
|
|
4028
|
+
method: 'POST',
|
|
2389
4029
|
}, options),
|
|
2390
4030
|
params,
|
|
2391
|
-
requiredParams: ['
|
|
2392
|
-
pathParams: ['
|
|
4031
|
+
requiredParams: ['servingConfig'],
|
|
4032
|
+
pathParams: ['servingConfig'],
|
|
2393
4033
|
context: this.context,
|
|
2394
4034
|
};
|
|
2395
4035
|
if (callback) {
|
|
@@ -2400,20 +4040,14 @@ var discoveryengine_v1beta;
|
|
|
2400
4040
|
}
|
|
2401
4041
|
}
|
|
2402
4042
|
}
|
|
2403
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$
|
|
2404
|
-
class Resource$Projects$Locations$Datastores$
|
|
2405
|
-
constructor(context) {
|
|
2406
|
-
this.context = context;
|
|
2407
|
-
this.operations =
|
|
2408
|
-
new Resource$Projects$Locations$Datastores$Models$Operations(this.context);
|
|
2409
|
-
}
|
|
2410
|
-
}
|
|
2411
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Models = Resource$Projects$Locations$Datastores$Models;
|
|
2412
|
-
class Resource$Projects$Locations$Datastores$Models$Operations {
|
|
4043
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Servingconfigs = Resource$Projects$Locations$Datastores$Servingconfigs;
|
|
4044
|
+
class Resource$Projects$Locations$Datastores$Sitesearchengine {
|
|
2413
4045
|
constructor(context) {
|
|
2414
4046
|
this.context = context;
|
|
4047
|
+
this.targetSites =
|
|
4048
|
+
new Resource$Projects$Locations$Datastores$Sitesearchengine$Targetsites(this.context);
|
|
2415
4049
|
}
|
|
2416
|
-
|
|
4050
|
+
disableAdvancedSiteSearch(paramsOrCallback, optionsOrCallback, callback) {
|
|
2417
4051
|
let params = (paramsOrCallback ||
|
|
2418
4052
|
{});
|
|
2419
4053
|
let options = (optionsOrCallback || {});
|
|
@@ -2430,12 +4064,12 @@ var discoveryengine_v1beta;
|
|
|
2430
4064
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2431
4065
|
const parameters = {
|
|
2432
4066
|
options: Object.assign({
|
|
2433
|
-
url: (rootUrl + '/v1beta/{+
|
|
2434
|
-
method: '
|
|
4067
|
+
url: (rootUrl + '/v1beta/{+siteSearchEngine}:disableAdvancedSiteSearch').replace(/([^:]\/)\/+/g, '$1'),
|
|
4068
|
+
method: 'POST',
|
|
2435
4069
|
}, options),
|
|
2436
4070
|
params,
|
|
2437
|
-
requiredParams: ['
|
|
2438
|
-
pathParams: ['
|
|
4071
|
+
requiredParams: ['siteSearchEngine'],
|
|
4072
|
+
pathParams: ['siteSearchEngine'],
|
|
2439
4073
|
context: this.context,
|
|
2440
4074
|
};
|
|
2441
4075
|
if (callback) {
|
|
@@ -2445,7 +4079,7 @@ var discoveryengine_v1beta;
|
|
|
2445
4079
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2446
4080
|
}
|
|
2447
4081
|
}
|
|
2448
|
-
|
|
4082
|
+
enableAdvancedSiteSearch(paramsOrCallback, optionsOrCallback, callback) {
|
|
2449
4083
|
let params = (paramsOrCallback ||
|
|
2450
4084
|
{});
|
|
2451
4085
|
let options = (optionsOrCallback || {});
|
|
@@ -2462,12 +4096,12 @@ var discoveryengine_v1beta;
|
|
|
2462
4096
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2463
4097
|
const parameters = {
|
|
2464
4098
|
options: Object.assign({
|
|
2465
|
-
url: (rootUrl + '/v1beta/{+
|
|
2466
|
-
method: '
|
|
4099
|
+
url: (rootUrl + '/v1beta/{+siteSearchEngine}:enableAdvancedSiteSearch').replace(/([^:]\/)\/+/g, '$1'),
|
|
4100
|
+
method: 'POST',
|
|
2467
4101
|
}, options),
|
|
2468
4102
|
params,
|
|
2469
|
-
requiredParams: ['
|
|
2470
|
-
pathParams: ['
|
|
4103
|
+
requiredParams: ['siteSearchEngine'],
|
|
4104
|
+
pathParams: ['siteSearchEngine'],
|
|
2471
4105
|
context: this.context,
|
|
2472
4106
|
};
|
|
2473
4107
|
if (callback) {
|
|
@@ -2477,13 +4111,7 @@ var discoveryengine_v1beta;
|
|
|
2477
4111
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2478
4112
|
}
|
|
2479
4113
|
}
|
|
2480
|
-
|
|
2481
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Models$Operations = Resource$Projects$Locations$Datastores$Models$Operations;
|
|
2482
|
-
class Resource$Projects$Locations$Datastores$Operations {
|
|
2483
|
-
constructor(context) {
|
|
2484
|
-
this.context = context;
|
|
2485
|
-
}
|
|
2486
|
-
get(paramsOrCallback, optionsOrCallback, callback) {
|
|
4114
|
+
recrawlUris(paramsOrCallback, optionsOrCallback, callback) {
|
|
2487
4115
|
let params = (paramsOrCallback ||
|
|
2488
4116
|
{});
|
|
2489
4117
|
let options = (optionsOrCallback || {});
|
|
@@ -2500,12 +4128,12 @@ var discoveryengine_v1beta;
|
|
|
2500
4128
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2501
4129
|
const parameters = {
|
|
2502
4130
|
options: Object.assign({
|
|
2503
|
-
url: (rootUrl + '/v1beta/{+
|
|
2504
|
-
method: '
|
|
4131
|
+
url: (rootUrl + '/v1beta/{+siteSearchEngine}:recrawlUris').replace(/([^:]\/)\/+/g, '$1'),
|
|
4132
|
+
method: 'POST',
|
|
2505
4133
|
}, options),
|
|
2506
4134
|
params,
|
|
2507
|
-
requiredParams: ['
|
|
2508
|
-
pathParams: ['
|
|
4135
|
+
requiredParams: ['siteSearchEngine'],
|
|
4136
|
+
pathParams: ['siteSearchEngine'],
|
|
2509
4137
|
context: this.context,
|
|
2510
4138
|
};
|
|
2511
4139
|
if (callback) {
|
|
@@ -2515,7 +4143,13 @@ var discoveryengine_v1beta;
|
|
|
2515
4143
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2516
4144
|
}
|
|
2517
4145
|
}
|
|
2518
|
-
|
|
4146
|
+
}
|
|
4147
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Sitesearchengine = Resource$Projects$Locations$Datastores$Sitesearchengine;
|
|
4148
|
+
class Resource$Projects$Locations$Datastores$Sitesearchengine$Targetsites {
|
|
4149
|
+
constructor(context) {
|
|
4150
|
+
this.context = context;
|
|
4151
|
+
}
|
|
4152
|
+
batchCreate(paramsOrCallback, optionsOrCallback, callback) {
|
|
2519
4153
|
let params = (paramsOrCallback ||
|
|
2520
4154
|
{});
|
|
2521
4155
|
let options = (optionsOrCallback || {});
|
|
@@ -2532,12 +4166,12 @@ var discoveryengine_v1beta;
|
|
|
2532
4166
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2533
4167
|
const parameters = {
|
|
2534
4168
|
options: Object.assign({
|
|
2535
|
-
url: (rootUrl + '/v1beta/{+
|
|
2536
|
-
method: '
|
|
4169
|
+
url: (rootUrl + '/v1beta/{+parent}/targetSites:batchCreate').replace(/([^:]\/)\/+/g, '$1'),
|
|
4170
|
+
method: 'POST',
|
|
2537
4171
|
}, options),
|
|
2538
4172
|
params,
|
|
2539
|
-
requiredParams: ['
|
|
2540
|
-
pathParams: ['
|
|
4173
|
+
requiredParams: ['parent'],
|
|
4174
|
+
pathParams: ['parent'],
|
|
2541
4175
|
context: this.context,
|
|
2542
4176
|
};
|
|
2543
4177
|
if (callback) {
|
|
@@ -2547,12 +4181,6 @@ var discoveryengine_v1beta;
|
|
|
2547
4181
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2548
4182
|
}
|
|
2549
4183
|
}
|
|
2550
|
-
}
|
|
2551
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Operations = Resource$Projects$Locations$Datastores$Operations;
|
|
2552
|
-
class Resource$Projects$Locations$Datastores$Schemas {
|
|
2553
|
-
constructor(context) {
|
|
2554
|
-
this.context = context;
|
|
2555
|
-
}
|
|
2556
4184
|
create(paramsOrCallback, optionsOrCallback, callback) {
|
|
2557
4185
|
let params = (paramsOrCallback ||
|
|
2558
4186
|
{});
|
|
@@ -2570,7 +4198,7 @@ var discoveryengine_v1beta;
|
|
|
2570
4198
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2571
4199
|
const parameters = {
|
|
2572
4200
|
options: Object.assign({
|
|
2573
|
-
url: (rootUrl + '/v1beta/{+parent}/
|
|
4201
|
+
url: (rootUrl + '/v1beta/{+parent}/targetSites').replace(/([^:]\/)\/+/g, '$1'),
|
|
2574
4202
|
method: 'POST',
|
|
2575
4203
|
}, options),
|
|
2576
4204
|
params,
|
|
@@ -2666,7 +4294,7 @@ var discoveryengine_v1beta;
|
|
|
2666
4294
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2667
4295
|
const parameters = {
|
|
2668
4296
|
options: Object.assign({
|
|
2669
|
-
url: (rootUrl + '/v1beta/{+parent}/
|
|
4297
|
+
url: (rootUrl + '/v1beta/{+parent}/targetSites').replace(/([^:]\/)\/+/g, '$1'),
|
|
2670
4298
|
method: 'GET',
|
|
2671
4299
|
}, options),
|
|
2672
4300
|
params,
|
|
@@ -2714,12 +4342,12 @@ var discoveryengine_v1beta;
|
|
|
2714
4342
|
}
|
|
2715
4343
|
}
|
|
2716
4344
|
}
|
|
2717
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$
|
|
2718
|
-
class Resource$Projects$Locations$Datastores$
|
|
4345
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Sitesearchengine$Targetsites = Resource$Projects$Locations$Datastores$Sitesearchengine$Targetsites;
|
|
4346
|
+
class Resource$Projects$Locations$Datastores$Suggestiondenylistentries {
|
|
2719
4347
|
constructor(context) {
|
|
2720
4348
|
this.context = context;
|
|
2721
4349
|
}
|
|
2722
|
-
|
|
4350
|
+
import(paramsOrCallback, optionsOrCallback, callback) {
|
|
2723
4351
|
let params = (paramsOrCallback ||
|
|
2724
4352
|
{});
|
|
2725
4353
|
let options = (optionsOrCallback || {});
|
|
@@ -2736,12 +4364,12 @@ var discoveryengine_v1beta;
|
|
|
2736
4364
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2737
4365
|
const parameters = {
|
|
2738
4366
|
options: Object.assign({
|
|
2739
|
-
url: (rootUrl + '/v1beta/{+
|
|
4367
|
+
url: (rootUrl + '/v1beta/{+parent}/suggestionDenyListEntries:import').replace(/([^:]\/)\/+/g, '$1'),
|
|
2740
4368
|
method: 'POST',
|
|
2741
4369
|
}, options),
|
|
2742
4370
|
params,
|
|
2743
|
-
requiredParams: ['
|
|
2744
|
-
pathParams: ['
|
|
4371
|
+
requiredParams: ['parent'],
|
|
4372
|
+
pathParams: ['parent'],
|
|
2745
4373
|
context: this.context,
|
|
2746
4374
|
};
|
|
2747
4375
|
if (callback) {
|
|
@@ -2751,7 +4379,7 @@ var discoveryengine_v1beta;
|
|
|
2751
4379
|
return (0, googleapis_common_1.createAPIRequest)(parameters);
|
|
2752
4380
|
}
|
|
2753
4381
|
}
|
|
2754
|
-
|
|
4382
|
+
purge(paramsOrCallback, optionsOrCallback, callback) {
|
|
2755
4383
|
let params = (paramsOrCallback ||
|
|
2756
4384
|
{});
|
|
2757
4385
|
let options = (optionsOrCallback || {});
|
|
@@ -2768,12 +4396,12 @@ var discoveryengine_v1beta;
|
|
|
2768
4396
|
const rootUrl = options.rootUrl || 'https://discoveryengine.googleapis.com/';
|
|
2769
4397
|
const parameters = {
|
|
2770
4398
|
options: Object.assign({
|
|
2771
|
-
url: (rootUrl + '/v1beta/{+
|
|
4399
|
+
url: (rootUrl + '/v1beta/{+parent}/suggestionDenyListEntries:purge').replace(/([^:]\/)\/+/g, '$1'),
|
|
2772
4400
|
method: 'POST',
|
|
2773
4401
|
}, options),
|
|
2774
4402
|
params,
|
|
2775
|
-
requiredParams: ['
|
|
2776
|
-
pathParams: ['
|
|
4403
|
+
requiredParams: ['parent'],
|
|
4404
|
+
pathParams: ['parent'],
|
|
2777
4405
|
context: this.context,
|
|
2778
4406
|
};
|
|
2779
4407
|
if (callback) {
|
|
@@ -2784,7 +4412,7 @@ var discoveryengine_v1beta;
|
|
|
2784
4412
|
}
|
|
2785
4413
|
}
|
|
2786
4414
|
}
|
|
2787
|
-
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$
|
|
4415
|
+
discoveryengine_v1beta.Resource$Projects$Locations$Datastores$Suggestiondenylistentries = Resource$Projects$Locations$Datastores$Suggestiondenylistentries;
|
|
2788
4416
|
class Resource$Projects$Locations$Datastores$Userevents {
|
|
2789
4417
|
constructor(context) {
|
|
2790
4418
|
this.context = context;
|