@aws-sdk/client-athena 3.1136.0 → 3.1138.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/dist-cjs/index.js +3 -3
- package/dist-es/schemas/schemas_0.js +2 -2
- package/dist-types/Athena.d.ts +147 -141
- package/dist-types/ts3.4/Athena.d.ts +144 -140
- package/package.json +8 -8
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import {
|
|
2
2
|
HttpHandlerOptions as __HttpHandlerOptions,
|
|
3
|
+
MetricsRecorder as __MetricsRecorder,
|
|
3
4
|
PaginationConfiguration,
|
|
4
5
|
Paginator,
|
|
5
6
|
} from "@smithy/types";
|
|
@@ -275,10 +276,13 @@ import {
|
|
|
275
276
|
UpdateWorkGroupCommandInput,
|
|
276
277
|
UpdateWorkGroupCommandOutput,
|
|
277
278
|
} from "./commands/UpdateWorkGroupCommand";
|
|
279
|
+
export interface AthenaRequestOptions extends __HttpHandlerOptions {
|
|
280
|
+
metricsRecorder?: __MetricsRecorder<unknown>;
|
|
281
|
+
}
|
|
278
282
|
export interface Athena {
|
|
279
283
|
batchGetNamedQuery(
|
|
280
284
|
args: BatchGetNamedQueryCommandInput,
|
|
281
|
-
options?:
|
|
285
|
+
options?: AthenaRequestOptions,
|
|
282
286
|
): Promise<BatchGetNamedQueryCommandOutput>;
|
|
283
287
|
batchGetNamedQuery(
|
|
284
288
|
args: BatchGetNamedQueryCommandInput,
|
|
@@ -286,12 +290,12 @@ export interface Athena {
|
|
|
286
290
|
): void;
|
|
287
291
|
batchGetNamedQuery(
|
|
288
292
|
args: BatchGetNamedQueryCommandInput,
|
|
289
|
-
options:
|
|
293
|
+
options: AthenaRequestOptions,
|
|
290
294
|
cb: (err: any, data?: BatchGetNamedQueryCommandOutput) => void,
|
|
291
295
|
): void;
|
|
292
296
|
batchGetPreparedStatement(
|
|
293
297
|
args: BatchGetPreparedStatementCommandInput,
|
|
294
|
-
options?:
|
|
298
|
+
options?: AthenaRequestOptions,
|
|
295
299
|
): Promise<BatchGetPreparedStatementCommandOutput>;
|
|
296
300
|
batchGetPreparedStatement(
|
|
297
301
|
args: BatchGetPreparedStatementCommandInput,
|
|
@@ -299,12 +303,12 @@ export interface Athena {
|
|
|
299
303
|
): void;
|
|
300
304
|
batchGetPreparedStatement(
|
|
301
305
|
args: BatchGetPreparedStatementCommandInput,
|
|
302
|
-
options:
|
|
306
|
+
options: AthenaRequestOptions,
|
|
303
307
|
cb: (err: any, data?: BatchGetPreparedStatementCommandOutput) => void,
|
|
304
308
|
): void;
|
|
305
309
|
batchGetQueryExecution(
|
|
306
310
|
args: BatchGetQueryExecutionCommandInput,
|
|
307
|
-
options?:
|
|
311
|
+
options?: AthenaRequestOptions,
|
|
308
312
|
): Promise<BatchGetQueryExecutionCommandOutput>;
|
|
309
313
|
batchGetQueryExecution(
|
|
310
314
|
args: BatchGetQueryExecutionCommandInput,
|
|
@@ -312,12 +316,12 @@ export interface Athena {
|
|
|
312
316
|
): void;
|
|
313
317
|
batchGetQueryExecution(
|
|
314
318
|
args: BatchGetQueryExecutionCommandInput,
|
|
315
|
-
options:
|
|
319
|
+
options: AthenaRequestOptions,
|
|
316
320
|
cb: (err: any, data?: BatchGetQueryExecutionCommandOutput) => void,
|
|
317
321
|
): void;
|
|
318
322
|
cancelCapacityReservation(
|
|
319
323
|
args: CancelCapacityReservationCommandInput,
|
|
320
|
-
options?:
|
|
324
|
+
options?: AthenaRequestOptions,
|
|
321
325
|
): Promise<CancelCapacityReservationCommandOutput>;
|
|
322
326
|
cancelCapacityReservation(
|
|
323
327
|
args: CancelCapacityReservationCommandInput,
|
|
@@ -325,12 +329,12 @@ export interface Athena {
|
|
|
325
329
|
): void;
|
|
326
330
|
cancelCapacityReservation(
|
|
327
331
|
args: CancelCapacityReservationCommandInput,
|
|
328
|
-
options:
|
|
332
|
+
options: AthenaRequestOptions,
|
|
329
333
|
cb: (err: any, data?: CancelCapacityReservationCommandOutput) => void,
|
|
330
334
|
): void;
|
|
331
335
|
createCapacityReservation(
|
|
332
336
|
args: CreateCapacityReservationCommandInput,
|
|
333
|
-
options?:
|
|
337
|
+
options?: AthenaRequestOptions,
|
|
334
338
|
): Promise<CreateCapacityReservationCommandOutput>;
|
|
335
339
|
createCapacityReservation(
|
|
336
340
|
args: CreateCapacityReservationCommandInput,
|
|
@@ -338,12 +342,12 @@ export interface Athena {
|
|
|
338
342
|
): void;
|
|
339
343
|
createCapacityReservation(
|
|
340
344
|
args: CreateCapacityReservationCommandInput,
|
|
341
|
-
options:
|
|
345
|
+
options: AthenaRequestOptions,
|
|
342
346
|
cb: (err: any, data?: CreateCapacityReservationCommandOutput) => void,
|
|
343
347
|
): void;
|
|
344
348
|
createDataCatalog(
|
|
345
349
|
args: CreateDataCatalogCommandInput,
|
|
346
|
-
options?:
|
|
350
|
+
options?: AthenaRequestOptions,
|
|
347
351
|
): Promise<CreateDataCatalogCommandOutput>;
|
|
348
352
|
createDataCatalog(
|
|
349
353
|
args: CreateDataCatalogCommandInput,
|
|
@@ -351,12 +355,12 @@ export interface Athena {
|
|
|
351
355
|
): void;
|
|
352
356
|
createDataCatalog(
|
|
353
357
|
args: CreateDataCatalogCommandInput,
|
|
354
|
-
options:
|
|
358
|
+
options: AthenaRequestOptions,
|
|
355
359
|
cb: (err: any, data?: CreateDataCatalogCommandOutput) => void,
|
|
356
360
|
): void;
|
|
357
361
|
createNamedQuery(
|
|
358
362
|
args: CreateNamedQueryCommandInput,
|
|
359
|
-
options?:
|
|
363
|
+
options?: AthenaRequestOptions,
|
|
360
364
|
): Promise<CreateNamedQueryCommandOutput>;
|
|
361
365
|
createNamedQuery(
|
|
362
366
|
args: CreateNamedQueryCommandInput,
|
|
@@ -364,12 +368,12 @@ export interface Athena {
|
|
|
364
368
|
): void;
|
|
365
369
|
createNamedQuery(
|
|
366
370
|
args: CreateNamedQueryCommandInput,
|
|
367
|
-
options:
|
|
371
|
+
options: AthenaRequestOptions,
|
|
368
372
|
cb: (err: any, data?: CreateNamedQueryCommandOutput) => void,
|
|
369
373
|
): void;
|
|
370
374
|
createNotebook(
|
|
371
375
|
args: CreateNotebookCommandInput,
|
|
372
|
-
options?:
|
|
376
|
+
options?: AthenaRequestOptions,
|
|
373
377
|
): Promise<CreateNotebookCommandOutput>;
|
|
374
378
|
createNotebook(
|
|
375
379
|
args: CreateNotebookCommandInput,
|
|
@@ -377,12 +381,12 @@ export interface Athena {
|
|
|
377
381
|
): void;
|
|
378
382
|
createNotebook(
|
|
379
383
|
args: CreateNotebookCommandInput,
|
|
380
|
-
options:
|
|
384
|
+
options: AthenaRequestOptions,
|
|
381
385
|
cb: (err: any, data?: CreateNotebookCommandOutput) => void,
|
|
382
386
|
): void;
|
|
383
387
|
createPreparedStatement(
|
|
384
388
|
args: CreatePreparedStatementCommandInput,
|
|
385
|
-
options?:
|
|
389
|
+
options?: AthenaRequestOptions,
|
|
386
390
|
): Promise<CreatePreparedStatementCommandOutput>;
|
|
387
391
|
createPreparedStatement(
|
|
388
392
|
args: CreatePreparedStatementCommandInput,
|
|
@@ -390,12 +394,12 @@ export interface Athena {
|
|
|
390
394
|
): void;
|
|
391
395
|
createPreparedStatement(
|
|
392
396
|
args: CreatePreparedStatementCommandInput,
|
|
393
|
-
options:
|
|
397
|
+
options: AthenaRequestOptions,
|
|
394
398
|
cb: (err: any, data?: CreatePreparedStatementCommandOutput) => void,
|
|
395
399
|
): void;
|
|
396
400
|
createPresignedNotebookUrl(
|
|
397
401
|
args: CreatePresignedNotebookUrlCommandInput,
|
|
398
|
-
options?:
|
|
402
|
+
options?: AthenaRequestOptions,
|
|
399
403
|
): Promise<CreatePresignedNotebookUrlCommandOutput>;
|
|
400
404
|
createPresignedNotebookUrl(
|
|
401
405
|
args: CreatePresignedNotebookUrlCommandInput,
|
|
@@ -403,12 +407,12 @@ export interface Athena {
|
|
|
403
407
|
): void;
|
|
404
408
|
createPresignedNotebookUrl(
|
|
405
409
|
args: CreatePresignedNotebookUrlCommandInput,
|
|
406
|
-
options:
|
|
410
|
+
options: AthenaRequestOptions,
|
|
407
411
|
cb: (err: any, data?: CreatePresignedNotebookUrlCommandOutput) => void,
|
|
408
412
|
): void;
|
|
409
413
|
createWorkGroup(
|
|
410
414
|
args: CreateWorkGroupCommandInput,
|
|
411
|
-
options?:
|
|
415
|
+
options?: AthenaRequestOptions,
|
|
412
416
|
): Promise<CreateWorkGroupCommandOutput>;
|
|
413
417
|
createWorkGroup(
|
|
414
418
|
args: CreateWorkGroupCommandInput,
|
|
@@ -416,12 +420,12 @@ export interface Athena {
|
|
|
416
420
|
): void;
|
|
417
421
|
createWorkGroup(
|
|
418
422
|
args: CreateWorkGroupCommandInput,
|
|
419
|
-
options:
|
|
423
|
+
options: AthenaRequestOptions,
|
|
420
424
|
cb: (err: any, data?: CreateWorkGroupCommandOutput) => void,
|
|
421
425
|
): void;
|
|
422
426
|
deleteCapacityReservation(
|
|
423
427
|
args: DeleteCapacityReservationCommandInput,
|
|
424
|
-
options?:
|
|
428
|
+
options?: AthenaRequestOptions,
|
|
425
429
|
): Promise<DeleteCapacityReservationCommandOutput>;
|
|
426
430
|
deleteCapacityReservation(
|
|
427
431
|
args: DeleteCapacityReservationCommandInput,
|
|
@@ -429,12 +433,12 @@ export interface Athena {
|
|
|
429
433
|
): void;
|
|
430
434
|
deleteCapacityReservation(
|
|
431
435
|
args: DeleteCapacityReservationCommandInput,
|
|
432
|
-
options:
|
|
436
|
+
options: AthenaRequestOptions,
|
|
433
437
|
cb: (err: any, data?: DeleteCapacityReservationCommandOutput) => void,
|
|
434
438
|
): void;
|
|
435
439
|
deleteDataCatalog(
|
|
436
440
|
args: DeleteDataCatalogCommandInput,
|
|
437
|
-
options?:
|
|
441
|
+
options?: AthenaRequestOptions,
|
|
438
442
|
): Promise<DeleteDataCatalogCommandOutput>;
|
|
439
443
|
deleteDataCatalog(
|
|
440
444
|
args: DeleteDataCatalogCommandInput,
|
|
@@ -442,12 +446,12 @@ export interface Athena {
|
|
|
442
446
|
): void;
|
|
443
447
|
deleteDataCatalog(
|
|
444
448
|
args: DeleteDataCatalogCommandInput,
|
|
445
|
-
options:
|
|
449
|
+
options: AthenaRequestOptions,
|
|
446
450
|
cb: (err: any, data?: DeleteDataCatalogCommandOutput) => void,
|
|
447
451
|
): void;
|
|
448
452
|
deleteNamedQuery(
|
|
449
453
|
args: DeleteNamedQueryCommandInput,
|
|
450
|
-
options?:
|
|
454
|
+
options?: AthenaRequestOptions,
|
|
451
455
|
): Promise<DeleteNamedQueryCommandOutput>;
|
|
452
456
|
deleteNamedQuery(
|
|
453
457
|
args: DeleteNamedQueryCommandInput,
|
|
@@ -455,12 +459,12 @@ export interface Athena {
|
|
|
455
459
|
): void;
|
|
456
460
|
deleteNamedQuery(
|
|
457
461
|
args: DeleteNamedQueryCommandInput,
|
|
458
|
-
options:
|
|
462
|
+
options: AthenaRequestOptions,
|
|
459
463
|
cb: (err: any, data?: DeleteNamedQueryCommandOutput) => void,
|
|
460
464
|
): void;
|
|
461
465
|
deleteNotebook(
|
|
462
466
|
args: DeleteNotebookCommandInput,
|
|
463
|
-
options?:
|
|
467
|
+
options?: AthenaRequestOptions,
|
|
464
468
|
): Promise<DeleteNotebookCommandOutput>;
|
|
465
469
|
deleteNotebook(
|
|
466
470
|
args: DeleteNotebookCommandInput,
|
|
@@ -468,12 +472,12 @@ export interface Athena {
|
|
|
468
472
|
): void;
|
|
469
473
|
deleteNotebook(
|
|
470
474
|
args: DeleteNotebookCommandInput,
|
|
471
|
-
options:
|
|
475
|
+
options: AthenaRequestOptions,
|
|
472
476
|
cb: (err: any, data?: DeleteNotebookCommandOutput) => void,
|
|
473
477
|
): void;
|
|
474
478
|
deletePreparedStatement(
|
|
475
479
|
args: DeletePreparedStatementCommandInput,
|
|
476
|
-
options?:
|
|
480
|
+
options?: AthenaRequestOptions,
|
|
477
481
|
): Promise<DeletePreparedStatementCommandOutput>;
|
|
478
482
|
deletePreparedStatement(
|
|
479
483
|
args: DeletePreparedStatementCommandInput,
|
|
@@ -481,12 +485,12 @@ export interface Athena {
|
|
|
481
485
|
): void;
|
|
482
486
|
deletePreparedStatement(
|
|
483
487
|
args: DeletePreparedStatementCommandInput,
|
|
484
|
-
options:
|
|
488
|
+
options: AthenaRequestOptions,
|
|
485
489
|
cb: (err: any, data?: DeletePreparedStatementCommandOutput) => void,
|
|
486
490
|
): void;
|
|
487
491
|
deleteWorkGroup(
|
|
488
492
|
args: DeleteWorkGroupCommandInput,
|
|
489
|
-
options?:
|
|
493
|
+
options?: AthenaRequestOptions,
|
|
490
494
|
): Promise<DeleteWorkGroupCommandOutput>;
|
|
491
495
|
deleteWorkGroup(
|
|
492
496
|
args: DeleteWorkGroupCommandInput,
|
|
@@ -494,12 +498,12 @@ export interface Athena {
|
|
|
494
498
|
): void;
|
|
495
499
|
deleteWorkGroup(
|
|
496
500
|
args: DeleteWorkGroupCommandInput,
|
|
497
|
-
options:
|
|
501
|
+
options: AthenaRequestOptions,
|
|
498
502
|
cb: (err: any, data?: DeleteWorkGroupCommandOutput) => void,
|
|
499
503
|
): void;
|
|
500
504
|
exportNotebook(
|
|
501
505
|
args: ExportNotebookCommandInput,
|
|
502
|
-
options?:
|
|
506
|
+
options?: AthenaRequestOptions,
|
|
503
507
|
): Promise<ExportNotebookCommandOutput>;
|
|
504
508
|
exportNotebook(
|
|
505
509
|
args: ExportNotebookCommandInput,
|
|
@@ -507,12 +511,12 @@ export interface Athena {
|
|
|
507
511
|
): void;
|
|
508
512
|
exportNotebook(
|
|
509
513
|
args: ExportNotebookCommandInput,
|
|
510
|
-
options:
|
|
514
|
+
options: AthenaRequestOptions,
|
|
511
515
|
cb: (err: any, data?: ExportNotebookCommandOutput) => void,
|
|
512
516
|
): void;
|
|
513
517
|
getCalculationExecution(
|
|
514
518
|
args: GetCalculationExecutionCommandInput,
|
|
515
|
-
options?:
|
|
519
|
+
options?: AthenaRequestOptions,
|
|
516
520
|
): Promise<GetCalculationExecutionCommandOutput>;
|
|
517
521
|
getCalculationExecution(
|
|
518
522
|
args: GetCalculationExecutionCommandInput,
|
|
@@ -520,12 +524,12 @@ export interface Athena {
|
|
|
520
524
|
): void;
|
|
521
525
|
getCalculationExecution(
|
|
522
526
|
args: GetCalculationExecutionCommandInput,
|
|
523
|
-
options:
|
|
527
|
+
options: AthenaRequestOptions,
|
|
524
528
|
cb: (err: any, data?: GetCalculationExecutionCommandOutput) => void,
|
|
525
529
|
): void;
|
|
526
530
|
getCalculationExecutionCode(
|
|
527
531
|
args: GetCalculationExecutionCodeCommandInput,
|
|
528
|
-
options?:
|
|
532
|
+
options?: AthenaRequestOptions,
|
|
529
533
|
): Promise<GetCalculationExecutionCodeCommandOutput>;
|
|
530
534
|
getCalculationExecutionCode(
|
|
531
535
|
args: GetCalculationExecutionCodeCommandInput,
|
|
@@ -533,12 +537,12 @@ export interface Athena {
|
|
|
533
537
|
): void;
|
|
534
538
|
getCalculationExecutionCode(
|
|
535
539
|
args: GetCalculationExecutionCodeCommandInput,
|
|
536
|
-
options:
|
|
540
|
+
options: AthenaRequestOptions,
|
|
537
541
|
cb: (err: any, data?: GetCalculationExecutionCodeCommandOutput) => void,
|
|
538
542
|
): void;
|
|
539
543
|
getCalculationExecutionStatus(
|
|
540
544
|
args: GetCalculationExecutionStatusCommandInput,
|
|
541
|
-
options?:
|
|
545
|
+
options?: AthenaRequestOptions,
|
|
542
546
|
): Promise<GetCalculationExecutionStatusCommandOutput>;
|
|
543
547
|
getCalculationExecutionStatus(
|
|
544
548
|
args: GetCalculationExecutionStatusCommandInput,
|
|
@@ -546,12 +550,12 @@ export interface Athena {
|
|
|
546
550
|
): void;
|
|
547
551
|
getCalculationExecutionStatus(
|
|
548
552
|
args: GetCalculationExecutionStatusCommandInput,
|
|
549
|
-
options:
|
|
553
|
+
options: AthenaRequestOptions,
|
|
550
554
|
cb: (err: any, data?: GetCalculationExecutionStatusCommandOutput) => void,
|
|
551
555
|
): void;
|
|
552
556
|
getCapacityAssignmentConfiguration(
|
|
553
557
|
args: GetCapacityAssignmentConfigurationCommandInput,
|
|
554
|
-
options?:
|
|
558
|
+
options?: AthenaRequestOptions,
|
|
555
559
|
): Promise<GetCapacityAssignmentConfigurationCommandOutput>;
|
|
556
560
|
getCapacityAssignmentConfiguration(
|
|
557
561
|
args: GetCapacityAssignmentConfigurationCommandInput,
|
|
@@ -559,12 +563,12 @@ export interface Athena {
|
|
|
559
563
|
): void;
|
|
560
564
|
getCapacityAssignmentConfiguration(
|
|
561
565
|
args: GetCapacityAssignmentConfigurationCommandInput,
|
|
562
|
-
options:
|
|
566
|
+
options: AthenaRequestOptions,
|
|
563
567
|
cb: (err: any, data?: GetCapacityAssignmentConfigurationCommandOutput) => void,
|
|
564
568
|
): void;
|
|
565
569
|
getCapacityReservation(
|
|
566
570
|
args: GetCapacityReservationCommandInput,
|
|
567
|
-
options?:
|
|
571
|
+
options?: AthenaRequestOptions,
|
|
568
572
|
): Promise<GetCapacityReservationCommandOutput>;
|
|
569
573
|
getCapacityReservation(
|
|
570
574
|
args: GetCapacityReservationCommandInput,
|
|
@@ -572,12 +576,12 @@ export interface Athena {
|
|
|
572
576
|
): void;
|
|
573
577
|
getCapacityReservation(
|
|
574
578
|
args: GetCapacityReservationCommandInput,
|
|
575
|
-
options:
|
|
579
|
+
options: AthenaRequestOptions,
|
|
576
580
|
cb: (err: any, data?: GetCapacityReservationCommandOutput) => void,
|
|
577
581
|
): void;
|
|
578
582
|
getDatabase(
|
|
579
583
|
args: GetDatabaseCommandInput,
|
|
580
|
-
options?:
|
|
584
|
+
options?: AthenaRequestOptions,
|
|
581
585
|
): Promise<GetDatabaseCommandOutput>;
|
|
582
586
|
getDatabase(
|
|
583
587
|
args: GetDatabaseCommandInput,
|
|
@@ -585,12 +589,12 @@ export interface Athena {
|
|
|
585
589
|
): void;
|
|
586
590
|
getDatabase(
|
|
587
591
|
args: GetDatabaseCommandInput,
|
|
588
|
-
options:
|
|
592
|
+
options: AthenaRequestOptions,
|
|
589
593
|
cb: (err: any, data?: GetDatabaseCommandOutput) => void,
|
|
590
594
|
): void;
|
|
591
595
|
getDataCatalog(
|
|
592
596
|
args: GetDataCatalogCommandInput,
|
|
593
|
-
options?:
|
|
597
|
+
options?: AthenaRequestOptions,
|
|
594
598
|
): Promise<GetDataCatalogCommandOutput>;
|
|
595
599
|
getDataCatalog(
|
|
596
600
|
args: GetDataCatalogCommandInput,
|
|
@@ -598,12 +602,12 @@ export interface Athena {
|
|
|
598
602
|
): void;
|
|
599
603
|
getDataCatalog(
|
|
600
604
|
args: GetDataCatalogCommandInput,
|
|
601
|
-
options:
|
|
605
|
+
options: AthenaRequestOptions,
|
|
602
606
|
cb: (err: any, data?: GetDataCatalogCommandOutput) => void,
|
|
603
607
|
): void;
|
|
604
608
|
getNamedQuery(
|
|
605
609
|
args: GetNamedQueryCommandInput,
|
|
606
|
-
options?:
|
|
610
|
+
options?: AthenaRequestOptions,
|
|
607
611
|
): Promise<GetNamedQueryCommandOutput>;
|
|
608
612
|
getNamedQuery(
|
|
609
613
|
args: GetNamedQueryCommandInput,
|
|
@@ -611,12 +615,12 @@ export interface Athena {
|
|
|
611
615
|
): void;
|
|
612
616
|
getNamedQuery(
|
|
613
617
|
args: GetNamedQueryCommandInput,
|
|
614
|
-
options:
|
|
618
|
+
options: AthenaRequestOptions,
|
|
615
619
|
cb: (err: any, data?: GetNamedQueryCommandOutput) => void,
|
|
616
620
|
): void;
|
|
617
621
|
getNotebookMetadata(
|
|
618
622
|
args: GetNotebookMetadataCommandInput,
|
|
619
|
-
options?:
|
|
623
|
+
options?: AthenaRequestOptions,
|
|
620
624
|
): Promise<GetNotebookMetadataCommandOutput>;
|
|
621
625
|
getNotebookMetadata(
|
|
622
626
|
args: GetNotebookMetadataCommandInput,
|
|
@@ -624,12 +628,12 @@ export interface Athena {
|
|
|
624
628
|
): void;
|
|
625
629
|
getNotebookMetadata(
|
|
626
630
|
args: GetNotebookMetadataCommandInput,
|
|
627
|
-
options:
|
|
631
|
+
options: AthenaRequestOptions,
|
|
628
632
|
cb: (err: any, data?: GetNotebookMetadataCommandOutput) => void,
|
|
629
633
|
): void;
|
|
630
634
|
getPreparedStatement(
|
|
631
635
|
args: GetPreparedStatementCommandInput,
|
|
632
|
-
options?:
|
|
636
|
+
options?: AthenaRequestOptions,
|
|
633
637
|
): Promise<GetPreparedStatementCommandOutput>;
|
|
634
638
|
getPreparedStatement(
|
|
635
639
|
args: GetPreparedStatementCommandInput,
|
|
@@ -637,12 +641,12 @@ export interface Athena {
|
|
|
637
641
|
): void;
|
|
638
642
|
getPreparedStatement(
|
|
639
643
|
args: GetPreparedStatementCommandInput,
|
|
640
|
-
options:
|
|
644
|
+
options: AthenaRequestOptions,
|
|
641
645
|
cb: (err: any, data?: GetPreparedStatementCommandOutput) => void,
|
|
642
646
|
): void;
|
|
643
647
|
getQueryExecution(
|
|
644
648
|
args: GetQueryExecutionCommandInput,
|
|
645
|
-
options?:
|
|
649
|
+
options?: AthenaRequestOptions,
|
|
646
650
|
): Promise<GetQueryExecutionCommandOutput>;
|
|
647
651
|
getQueryExecution(
|
|
648
652
|
args: GetQueryExecutionCommandInput,
|
|
@@ -650,12 +654,12 @@ export interface Athena {
|
|
|
650
654
|
): void;
|
|
651
655
|
getQueryExecution(
|
|
652
656
|
args: GetQueryExecutionCommandInput,
|
|
653
|
-
options:
|
|
657
|
+
options: AthenaRequestOptions,
|
|
654
658
|
cb: (err: any, data?: GetQueryExecutionCommandOutput) => void,
|
|
655
659
|
): void;
|
|
656
660
|
getQueryResults(
|
|
657
661
|
args: GetQueryResultsCommandInput,
|
|
658
|
-
options?:
|
|
662
|
+
options?: AthenaRequestOptions,
|
|
659
663
|
): Promise<GetQueryResultsCommandOutput>;
|
|
660
664
|
getQueryResults(
|
|
661
665
|
args: GetQueryResultsCommandInput,
|
|
@@ -663,12 +667,12 @@ export interface Athena {
|
|
|
663
667
|
): void;
|
|
664
668
|
getQueryResults(
|
|
665
669
|
args: GetQueryResultsCommandInput,
|
|
666
|
-
options:
|
|
670
|
+
options: AthenaRequestOptions,
|
|
667
671
|
cb: (err: any, data?: GetQueryResultsCommandOutput) => void,
|
|
668
672
|
): void;
|
|
669
673
|
getQueryRuntimeStatistics(
|
|
670
674
|
args: GetQueryRuntimeStatisticsCommandInput,
|
|
671
|
-
options?:
|
|
675
|
+
options?: AthenaRequestOptions,
|
|
672
676
|
): Promise<GetQueryRuntimeStatisticsCommandOutput>;
|
|
673
677
|
getQueryRuntimeStatistics(
|
|
674
678
|
args: GetQueryRuntimeStatisticsCommandInput,
|
|
@@ -676,12 +680,12 @@ export interface Athena {
|
|
|
676
680
|
): void;
|
|
677
681
|
getQueryRuntimeStatistics(
|
|
678
682
|
args: GetQueryRuntimeStatisticsCommandInput,
|
|
679
|
-
options:
|
|
683
|
+
options: AthenaRequestOptions,
|
|
680
684
|
cb: (err: any, data?: GetQueryRuntimeStatisticsCommandOutput) => void,
|
|
681
685
|
): void;
|
|
682
686
|
getResourceDashboard(
|
|
683
687
|
args: GetResourceDashboardCommandInput,
|
|
684
|
-
options?:
|
|
688
|
+
options?: AthenaRequestOptions,
|
|
685
689
|
): Promise<GetResourceDashboardCommandOutput>;
|
|
686
690
|
getResourceDashboard(
|
|
687
691
|
args: GetResourceDashboardCommandInput,
|
|
@@ -689,12 +693,12 @@ export interface Athena {
|
|
|
689
693
|
): void;
|
|
690
694
|
getResourceDashboard(
|
|
691
695
|
args: GetResourceDashboardCommandInput,
|
|
692
|
-
options:
|
|
696
|
+
options: AthenaRequestOptions,
|
|
693
697
|
cb: (err: any, data?: GetResourceDashboardCommandOutput) => void,
|
|
694
698
|
): void;
|
|
695
699
|
getSession(
|
|
696
700
|
args: GetSessionCommandInput,
|
|
697
|
-
options?:
|
|
701
|
+
options?: AthenaRequestOptions,
|
|
698
702
|
): Promise<GetSessionCommandOutput>;
|
|
699
703
|
getSession(
|
|
700
704
|
args: GetSessionCommandInput,
|
|
@@ -702,12 +706,12 @@ export interface Athena {
|
|
|
702
706
|
): void;
|
|
703
707
|
getSession(
|
|
704
708
|
args: GetSessionCommandInput,
|
|
705
|
-
options:
|
|
709
|
+
options: AthenaRequestOptions,
|
|
706
710
|
cb: (err: any, data?: GetSessionCommandOutput) => void,
|
|
707
711
|
): void;
|
|
708
712
|
getSessionEndpoint(
|
|
709
713
|
args: GetSessionEndpointCommandInput,
|
|
710
|
-
options?:
|
|
714
|
+
options?: AthenaRequestOptions,
|
|
711
715
|
): Promise<GetSessionEndpointCommandOutput>;
|
|
712
716
|
getSessionEndpoint(
|
|
713
717
|
args: GetSessionEndpointCommandInput,
|
|
@@ -715,12 +719,12 @@ export interface Athena {
|
|
|
715
719
|
): void;
|
|
716
720
|
getSessionEndpoint(
|
|
717
721
|
args: GetSessionEndpointCommandInput,
|
|
718
|
-
options:
|
|
722
|
+
options: AthenaRequestOptions,
|
|
719
723
|
cb: (err: any, data?: GetSessionEndpointCommandOutput) => void,
|
|
720
724
|
): void;
|
|
721
725
|
getSessionStatus(
|
|
722
726
|
args: GetSessionStatusCommandInput,
|
|
723
|
-
options?:
|
|
727
|
+
options?: AthenaRequestOptions,
|
|
724
728
|
): Promise<GetSessionStatusCommandOutput>;
|
|
725
729
|
getSessionStatus(
|
|
726
730
|
args: GetSessionStatusCommandInput,
|
|
@@ -728,12 +732,12 @@ export interface Athena {
|
|
|
728
732
|
): void;
|
|
729
733
|
getSessionStatus(
|
|
730
734
|
args: GetSessionStatusCommandInput,
|
|
731
|
-
options:
|
|
735
|
+
options: AthenaRequestOptions,
|
|
732
736
|
cb: (err: any, data?: GetSessionStatusCommandOutput) => void,
|
|
733
737
|
): void;
|
|
734
738
|
getTableMetadata(
|
|
735
739
|
args: GetTableMetadataCommandInput,
|
|
736
|
-
options?:
|
|
740
|
+
options?: AthenaRequestOptions,
|
|
737
741
|
): Promise<GetTableMetadataCommandOutput>;
|
|
738
742
|
getTableMetadata(
|
|
739
743
|
args: GetTableMetadataCommandInput,
|
|
@@ -741,12 +745,12 @@ export interface Athena {
|
|
|
741
745
|
): void;
|
|
742
746
|
getTableMetadata(
|
|
743
747
|
args: GetTableMetadataCommandInput,
|
|
744
|
-
options:
|
|
748
|
+
options: AthenaRequestOptions,
|
|
745
749
|
cb: (err: any, data?: GetTableMetadataCommandOutput) => void,
|
|
746
750
|
): void;
|
|
747
751
|
getWorkGroup(
|
|
748
752
|
args: GetWorkGroupCommandInput,
|
|
749
|
-
options?:
|
|
753
|
+
options?: AthenaRequestOptions,
|
|
750
754
|
): Promise<GetWorkGroupCommandOutput>;
|
|
751
755
|
getWorkGroup(
|
|
752
756
|
args: GetWorkGroupCommandInput,
|
|
@@ -754,12 +758,12 @@ export interface Athena {
|
|
|
754
758
|
): void;
|
|
755
759
|
getWorkGroup(
|
|
756
760
|
args: GetWorkGroupCommandInput,
|
|
757
|
-
options:
|
|
761
|
+
options: AthenaRequestOptions,
|
|
758
762
|
cb: (err: any, data?: GetWorkGroupCommandOutput) => void,
|
|
759
763
|
): void;
|
|
760
764
|
importNotebook(
|
|
761
765
|
args: ImportNotebookCommandInput,
|
|
762
|
-
options?:
|
|
766
|
+
options?: AthenaRequestOptions,
|
|
763
767
|
): Promise<ImportNotebookCommandOutput>;
|
|
764
768
|
importNotebook(
|
|
765
769
|
args: ImportNotebookCommandInput,
|
|
@@ -767,13 +771,13 @@ export interface Athena {
|
|
|
767
771
|
): void;
|
|
768
772
|
importNotebook(
|
|
769
773
|
args: ImportNotebookCommandInput,
|
|
770
|
-
options:
|
|
774
|
+
options: AthenaRequestOptions,
|
|
771
775
|
cb: (err: any, data?: ImportNotebookCommandOutput) => void,
|
|
772
776
|
): void;
|
|
773
777
|
listApplicationDPUSizes(): Promise<ListApplicationDPUSizesCommandOutput>;
|
|
774
778
|
listApplicationDPUSizes(
|
|
775
779
|
args: ListApplicationDPUSizesCommandInput,
|
|
776
|
-
options?:
|
|
780
|
+
options?: AthenaRequestOptions,
|
|
777
781
|
): Promise<ListApplicationDPUSizesCommandOutput>;
|
|
778
782
|
listApplicationDPUSizes(
|
|
779
783
|
args: ListApplicationDPUSizesCommandInput,
|
|
@@ -781,12 +785,12 @@ export interface Athena {
|
|
|
781
785
|
): void;
|
|
782
786
|
listApplicationDPUSizes(
|
|
783
787
|
args: ListApplicationDPUSizesCommandInput,
|
|
784
|
-
options:
|
|
788
|
+
options: AthenaRequestOptions,
|
|
785
789
|
cb: (err: any, data?: ListApplicationDPUSizesCommandOutput) => void,
|
|
786
790
|
): void;
|
|
787
791
|
listCalculationExecutions(
|
|
788
792
|
args: ListCalculationExecutionsCommandInput,
|
|
789
|
-
options?:
|
|
793
|
+
options?: AthenaRequestOptions,
|
|
790
794
|
): Promise<ListCalculationExecutionsCommandOutput>;
|
|
791
795
|
listCalculationExecutions(
|
|
792
796
|
args: ListCalculationExecutionsCommandInput,
|
|
@@ -794,13 +798,13 @@ export interface Athena {
|
|
|
794
798
|
): void;
|
|
795
799
|
listCalculationExecutions(
|
|
796
800
|
args: ListCalculationExecutionsCommandInput,
|
|
797
|
-
options:
|
|
801
|
+
options: AthenaRequestOptions,
|
|
798
802
|
cb: (err: any, data?: ListCalculationExecutionsCommandOutput) => void,
|
|
799
803
|
): void;
|
|
800
804
|
listCapacityReservations(): Promise<ListCapacityReservationsCommandOutput>;
|
|
801
805
|
listCapacityReservations(
|
|
802
806
|
args: ListCapacityReservationsCommandInput,
|
|
803
|
-
options?:
|
|
807
|
+
options?: AthenaRequestOptions,
|
|
804
808
|
): Promise<ListCapacityReservationsCommandOutput>;
|
|
805
809
|
listCapacityReservations(
|
|
806
810
|
args: ListCapacityReservationsCommandInput,
|
|
@@ -808,12 +812,12 @@ export interface Athena {
|
|
|
808
812
|
): void;
|
|
809
813
|
listCapacityReservations(
|
|
810
814
|
args: ListCapacityReservationsCommandInput,
|
|
811
|
-
options:
|
|
815
|
+
options: AthenaRequestOptions,
|
|
812
816
|
cb: (err: any, data?: ListCapacityReservationsCommandOutput) => void,
|
|
813
817
|
): void;
|
|
814
818
|
listDatabases(
|
|
815
819
|
args: ListDatabasesCommandInput,
|
|
816
|
-
options?:
|
|
820
|
+
options?: AthenaRequestOptions,
|
|
817
821
|
): Promise<ListDatabasesCommandOutput>;
|
|
818
822
|
listDatabases(
|
|
819
823
|
args: ListDatabasesCommandInput,
|
|
@@ -821,13 +825,13 @@ export interface Athena {
|
|
|
821
825
|
): void;
|
|
822
826
|
listDatabases(
|
|
823
827
|
args: ListDatabasesCommandInput,
|
|
824
|
-
options:
|
|
828
|
+
options: AthenaRequestOptions,
|
|
825
829
|
cb: (err: any, data?: ListDatabasesCommandOutput) => void,
|
|
826
830
|
): void;
|
|
827
831
|
listDataCatalogs(): Promise<ListDataCatalogsCommandOutput>;
|
|
828
832
|
listDataCatalogs(
|
|
829
833
|
args: ListDataCatalogsCommandInput,
|
|
830
|
-
options?:
|
|
834
|
+
options?: AthenaRequestOptions,
|
|
831
835
|
): Promise<ListDataCatalogsCommandOutput>;
|
|
832
836
|
listDataCatalogs(
|
|
833
837
|
args: ListDataCatalogsCommandInput,
|
|
@@ -835,13 +839,13 @@ export interface Athena {
|
|
|
835
839
|
): void;
|
|
836
840
|
listDataCatalogs(
|
|
837
841
|
args: ListDataCatalogsCommandInput,
|
|
838
|
-
options:
|
|
842
|
+
options: AthenaRequestOptions,
|
|
839
843
|
cb: (err: any, data?: ListDataCatalogsCommandOutput) => void,
|
|
840
844
|
): void;
|
|
841
845
|
listEngineVersions(): Promise<ListEngineVersionsCommandOutput>;
|
|
842
846
|
listEngineVersions(
|
|
843
847
|
args: ListEngineVersionsCommandInput,
|
|
844
|
-
options?:
|
|
848
|
+
options?: AthenaRequestOptions,
|
|
845
849
|
): Promise<ListEngineVersionsCommandOutput>;
|
|
846
850
|
listEngineVersions(
|
|
847
851
|
args: ListEngineVersionsCommandInput,
|
|
@@ -849,12 +853,12 @@ export interface Athena {
|
|
|
849
853
|
): void;
|
|
850
854
|
listEngineVersions(
|
|
851
855
|
args: ListEngineVersionsCommandInput,
|
|
852
|
-
options:
|
|
856
|
+
options: AthenaRequestOptions,
|
|
853
857
|
cb: (err: any, data?: ListEngineVersionsCommandOutput) => void,
|
|
854
858
|
): void;
|
|
855
859
|
listExecutors(
|
|
856
860
|
args: ListExecutorsCommandInput,
|
|
857
|
-
options?:
|
|
861
|
+
options?: AthenaRequestOptions,
|
|
858
862
|
): Promise<ListExecutorsCommandOutput>;
|
|
859
863
|
listExecutors(
|
|
860
864
|
args: ListExecutorsCommandInput,
|
|
@@ -862,13 +866,13 @@ export interface Athena {
|
|
|
862
866
|
): void;
|
|
863
867
|
listExecutors(
|
|
864
868
|
args: ListExecutorsCommandInput,
|
|
865
|
-
options:
|
|
869
|
+
options: AthenaRequestOptions,
|
|
866
870
|
cb: (err: any, data?: ListExecutorsCommandOutput) => void,
|
|
867
871
|
): void;
|
|
868
872
|
listNamedQueries(): Promise<ListNamedQueriesCommandOutput>;
|
|
869
873
|
listNamedQueries(
|
|
870
874
|
args: ListNamedQueriesCommandInput,
|
|
871
|
-
options?:
|
|
875
|
+
options?: AthenaRequestOptions,
|
|
872
876
|
): Promise<ListNamedQueriesCommandOutput>;
|
|
873
877
|
listNamedQueries(
|
|
874
878
|
args: ListNamedQueriesCommandInput,
|
|
@@ -876,12 +880,12 @@ export interface Athena {
|
|
|
876
880
|
): void;
|
|
877
881
|
listNamedQueries(
|
|
878
882
|
args: ListNamedQueriesCommandInput,
|
|
879
|
-
options:
|
|
883
|
+
options: AthenaRequestOptions,
|
|
880
884
|
cb: (err: any, data?: ListNamedQueriesCommandOutput) => void,
|
|
881
885
|
): void;
|
|
882
886
|
listNotebookMetadata(
|
|
883
887
|
args: ListNotebookMetadataCommandInput,
|
|
884
|
-
options?:
|
|
888
|
+
options?: AthenaRequestOptions,
|
|
885
889
|
): Promise<ListNotebookMetadataCommandOutput>;
|
|
886
890
|
listNotebookMetadata(
|
|
887
891
|
args: ListNotebookMetadataCommandInput,
|
|
@@ -889,12 +893,12 @@ export interface Athena {
|
|
|
889
893
|
): void;
|
|
890
894
|
listNotebookMetadata(
|
|
891
895
|
args: ListNotebookMetadataCommandInput,
|
|
892
|
-
options:
|
|
896
|
+
options: AthenaRequestOptions,
|
|
893
897
|
cb: (err: any, data?: ListNotebookMetadataCommandOutput) => void,
|
|
894
898
|
): void;
|
|
895
899
|
listNotebookSessions(
|
|
896
900
|
args: ListNotebookSessionsCommandInput,
|
|
897
|
-
options?:
|
|
901
|
+
options?: AthenaRequestOptions,
|
|
898
902
|
): Promise<ListNotebookSessionsCommandOutput>;
|
|
899
903
|
listNotebookSessions(
|
|
900
904
|
args: ListNotebookSessionsCommandInput,
|
|
@@ -902,12 +906,12 @@ export interface Athena {
|
|
|
902
906
|
): void;
|
|
903
907
|
listNotebookSessions(
|
|
904
908
|
args: ListNotebookSessionsCommandInput,
|
|
905
|
-
options:
|
|
909
|
+
options: AthenaRequestOptions,
|
|
906
910
|
cb: (err: any, data?: ListNotebookSessionsCommandOutput) => void,
|
|
907
911
|
): void;
|
|
908
912
|
listPreparedStatements(
|
|
909
913
|
args: ListPreparedStatementsCommandInput,
|
|
910
|
-
options?:
|
|
914
|
+
options?: AthenaRequestOptions,
|
|
911
915
|
): Promise<ListPreparedStatementsCommandOutput>;
|
|
912
916
|
listPreparedStatements(
|
|
913
917
|
args: ListPreparedStatementsCommandInput,
|
|
@@ -915,13 +919,13 @@ export interface Athena {
|
|
|
915
919
|
): void;
|
|
916
920
|
listPreparedStatements(
|
|
917
921
|
args: ListPreparedStatementsCommandInput,
|
|
918
|
-
options:
|
|
922
|
+
options: AthenaRequestOptions,
|
|
919
923
|
cb: (err: any, data?: ListPreparedStatementsCommandOutput) => void,
|
|
920
924
|
): void;
|
|
921
925
|
listQueryExecutions(): Promise<ListQueryExecutionsCommandOutput>;
|
|
922
926
|
listQueryExecutions(
|
|
923
927
|
args: ListQueryExecutionsCommandInput,
|
|
924
|
-
options?:
|
|
928
|
+
options?: AthenaRequestOptions,
|
|
925
929
|
): Promise<ListQueryExecutionsCommandOutput>;
|
|
926
930
|
listQueryExecutions(
|
|
927
931
|
args: ListQueryExecutionsCommandInput,
|
|
@@ -929,12 +933,12 @@ export interface Athena {
|
|
|
929
933
|
): void;
|
|
930
934
|
listQueryExecutions(
|
|
931
935
|
args: ListQueryExecutionsCommandInput,
|
|
932
|
-
options:
|
|
936
|
+
options: AthenaRequestOptions,
|
|
933
937
|
cb: (err: any, data?: ListQueryExecutionsCommandOutput) => void,
|
|
934
938
|
): void;
|
|
935
939
|
listSessions(
|
|
936
940
|
args: ListSessionsCommandInput,
|
|
937
|
-
options?:
|
|
941
|
+
options?: AthenaRequestOptions,
|
|
938
942
|
): Promise<ListSessionsCommandOutput>;
|
|
939
943
|
listSessions(
|
|
940
944
|
args: ListSessionsCommandInput,
|
|
@@ -942,12 +946,12 @@ export interface Athena {
|
|
|
942
946
|
): void;
|
|
943
947
|
listSessions(
|
|
944
948
|
args: ListSessionsCommandInput,
|
|
945
|
-
options:
|
|
949
|
+
options: AthenaRequestOptions,
|
|
946
950
|
cb: (err: any, data?: ListSessionsCommandOutput) => void,
|
|
947
951
|
): void;
|
|
948
952
|
listTableMetadata(
|
|
949
953
|
args: ListTableMetadataCommandInput,
|
|
950
|
-
options?:
|
|
954
|
+
options?: AthenaRequestOptions,
|
|
951
955
|
): Promise<ListTableMetadataCommandOutput>;
|
|
952
956
|
listTableMetadata(
|
|
953
957
|
args: ListTableMetadataCommandInput,
|
|
@@ -955,12 +959,12 @@ export interface Athena {
|
|
|
955
959
|
): void;
|
|
956
960
|
listTableMetadata(
|
|
957
961
|
args: ListTableMetadataCommandInput,
|
|
958
|
-
options:
|
|
962
|
+
options: AthenaRequestOptions,
|
|
959
963
|
cb: (err: any, data?: ListTableMetadataCommandOutput) => void,
|
|
960
964
|
): void;
|
|
961
965
|
listTagsForResource(
|
|
962
966
|
args: ListTagsForResourceCommandInput,
|
|
963
|
-
options?:
|
|
967
|
+
options?: AthenaRequestOptions,
|
|
964
968
|
): Promise<ListTagsForResourceCommandOutput>;
|
|
965
969
|
listTagsForResource(
|
|
966
970
|
args: ListTagsForResourceCommandInput,
|
|
@@ -968,13 +972,13 @@ export interface Athena {
|
|
|
968
972
|
): void;
|
|
969
973
|
listTagsForResource(
|
|
970
974
|
args: ListTagsForResourceCommandInput,
|
|
971
|
-
options:
|
|
975
|
+
options: AthenaRequestOptions,
|
|
972
976
|
cb: (err: any, data?: ListTagsForResourceCommandOutput) => void,
|
|
973
977
|
): void;
|
|
974
978
|
listWorkGroups(): Promise<ListWorkGroupsCommandOutput>;
|
|
975
979
|
listWorkGroups(
|
|
976
980
|
args: ListWorkGroupsCommandInput,
|
|
977
|
-
options?:
|
|
981
|
+
options?: AthenaRequestOptions,
|
|
978
982
|
): Promise<ListWorkGroupsCommandOutput>;
|
|
979
983
|
listWorkGroups(
|
|
980
984
|
args: ListWorkGroupsCommandInput,
|
|
@@ -982,12 +986,12 @@ export interface Athena {
|
|
|
982
986
|
): void;
|
|
983
987
|
listWorkGroups(
|
|
984
988
|
args: ListWorkGroupsCommandInput,
|
|
985
|
-
options:
|
|
989
|
+
options: AthenaRequestOptions,
|
|
986
990
|
cb: (err: any, data?: ListWorkGroupsCommandOutput) => void,
|
|
987
991
|
): void;
|
|
988
992
|
putCapacityAssignmentConfiguration(
|
|
989
993
|
args: PutCapacityAssignmentConfigurationCommandInput,
|
|
990
|
-
options?:
|
|
994
|
+
options?: AthenaRequestOptions,
|
|
991
995
|
): Promise<PutCapacityAssignmentConfigurationCommandOutput>;
|
|
992
996
|
putCapacityAssignmentConfiguration(
|
|
993
997
|
args: PutCapacityAssignmentConfigurationCommandInput,
|
|
@@ -995,12 +999,12 @@ export interface Athena {
|
|
|
995
999
|
): void;
|
|
996
1000
|
putCapacityAssignmentConfiguration(
|
|
997
1001
|
args: PutCapacityAssignmentConfigurationCommandInput,
|
|
998
|
-
options:
|
|
1002
|
+
options: AthenaRequestOptions,
|
|
999
1003
|
cb: (err: any, data?: PutCapacityAssignmentConfigurationCommandOutput) => void,
|
|
1000
1004
|
): void;
|
|
1001
1005
|
startCalculationExecution(
|
|
1002
1006
|
args: StartCalculationExecutionCommandInput,
|
|
1003
|
-
options?:
|
|
1007
|
+
options?: AthenaRequestOptions,
|
|
1004
1008
|
): Promise<StartCalculationExecutionCommandOutput>;
|
|
1005
1009
|
startCalculationExecution(
|
|
1006
1010
|
args: StartCalculationExecutionCommandInput,
|
|
@@ -1008,12 +1012,12 @@ export interface Athena {
|
|
|
1008
1012
|
): void;
|
|
1009
1013
|
startCalculationExecution(
|
|
1010
1014
|
args: StartCalculationExecutionCommandInput,
|
|
1011
|
-
options:
|
|
1015
|
+
options: AthenaRequestOptions,
|
|
1012
1016
|
cb: (err: any, data?: StartCalculationExecutionCommandOutput) => void,
|
|
1013
1017
|
): void;
|
|
1014
1018
|
startQueryExecution(
|
|
1015
1019
|
args: StartQueryExecutionCommandInput,
|
|
1016
|
-
options?:
|
|
1020
|
+
options?: AthenaRequestOptions,
|
|
1017
1021
|
): Promise<StartQueryExecutionCommandOutput>;
|
|
1018
1022
|
startQueryExecution(
|
|
1019
1023
|
args: StartQueryExecutionCommandInput,
|
|
@@ -1021,12 +1025,12 @@ export interface Athena {
|
|
|
1021
1025
|
): void;
|
|
1022
1026
|
startQueryExecution(
|
|
1023
1027
|
args: StartQueryExecutionCommandInput,
|
|
1024
|
-
options:
|
|
1028
|
+
options: AthenaRequestOptions,
|
|
1025
1029
|
cb: (err: any, data?: StartQueryExecutionCommandOutput) => void,
|
|
1026
1030
|
): void;
|
|
1027
1031
|
startSession(
|
|
1028
1032
|
args: StartSessionCommandInput,
|
|
1029
|
-
options?:
|
|
1033
|
+
options?: AthenaRequestOptions,
|
|
1030
1034
|
): Promise<StartSessionCommandOutput>;
|
|
1031
1035
|
startSession(
|
|
1032
1036
|
args: StartSessionCommandInput,
|
|
@@ -1034,12 +1038,12 @@ export interface Athena {
|
|
|
1034
1038
|
): void;
|
|
1035
1039
|
startSession(
|
|
1036
1040
|
args: StartSessionCommandInput,
|
|
1037
|
-
options:
|
|
1041
|
+
options: AthenaRequestOptions,
|
|
1038
1042
|
cb: (err: any, data?: StartSessionCommandOutput) => void,
|
|
1039
1043
|
): void;
|
|
1040
1044
|
stopCalculationExecution(
|
|
1041
1045
|
args: StopCalculationExecutionCommandInput,
|
|
1042
|
-
options?:
|
|
1046
|
+
options?: AthenaRequestOptions,
|
|
1043
1047
|
): Promise<StopCalculationExecutionCommandOutput>;
|
|
1044
1048
|
stopCalculationExecution(
|
|
1045
1049
|
args: StopCalculationExecutionCommandInput,
|
|
@@ -1047,12 +1051,12 @@ export interface Athena {
|
|
|
1047
1051
|
): void;
|
|
1048
1052
|
stopCalculationExecution(
|
|
1049
1053
|
args: StopCalculationExecutionCommandInput,
|
|
1050
|
-
options:
|
|
1054
|
+
options: AthenaRequestOptions,
|
|
1051
1055
|
cb: (err: any, data?: StopCalculationExecutionCommandOutput) => void,
|
|
1052
1056
|
): void;
|
|
1053
1057
|
stopQueryExecution(
|
|
1054
1058
|
args: StopQueryExecutionCommandInput,
|
|
1055
|
-
options?:
|
|
1059
|
+
options?: AthenaRequestOptions,
|
|
1056
1060
|
): Promise<StopQueryExecutionCommandOutput>;
|
|
1057
1061
|
stopQueryExecution(
|
|
1058
1062
|
args: StopQueryExecutionCommandInput,
|
|
@@ -1060,12 +1064,12 @@ export interface Athena {
|
|
|
1060
1064
|
): void;
|
|
1061
1065
|
stopQueryExecution(
|
|
1062
1066
|
args: StopQueryExecutionCommandInput,
|
|
1063
|
-
options:
|
|
1067
|
+
options: AthenaRequestOptions,
|
|
1064
1068
|
cb: (err: any, data?: StopQueryExecutionCommandOutput) => void,
|
|
1065
1069
|
): void;
|
|
1066
1070
|
tagResource(
|
|
1067
1071
|
args: TagResourceCommandInput,
|
|
1068
|
-
options?:
|
|
1072
|
+
options?: AthenaRequestOptions,
|
|
1069
1073
|
): Promise<TagResourceCommandOutput>;
|
|
1070
1074
|
tagResource(
|
|
1071
1075
|
args: TagResourceCommandInput,
|
|
@@ -1073,12 +1077,12 @@ export interface Athena {
|
|
|
1073
1077
|
): void;
|
|
1074
1078
|
tagResource(
|
|
1075
1079
|
args: TagResourceCommandInput,
|
|
1076
|
-
options:
|
|
1080
|
+
options: AthenaRequestOptions,
|
|
1077
1081
|
cb: (err: any, data?: TagResourceCommandOutput) => void,
|
|
1078
1082
|
): void;
|
|
1079
1083
|
terminateSession(
|
|
1080
1084
|
args: TerminateSessionCommandInput,
|
|
1081
|
-
options?:
|
|
1085
|
+
options?: AthenaRequestOptions,
|
|
1082
1086
|
): Promise<TerminateSessionCommandOutput>;
|
|
1083
1087
|
terminateSession(
|
|
1084
1088
|
args: TerminateSessionCommandInput,
|
|
@@ -1086,12 +1090,12 @@ export interface Athena {
|
|
|
1086
1090
|
): void;
|
|
1087
1091
|
terminateSession(
|
|
1088
1092
|
args: TerminateSessionCommandInput,
|
|
1089
|
-
options:
|
|
1093
|
+
options: AthenaRequestOptions,
|
|
1090
1094
|
cb: (err: any, data?: TerminateSessionCommandOutput) => void,
|
|
1091
1095
|
): void;
|
|
1092
1096
|
untagResource(
|
|
1093
1097
|
args: UntagResourceCommandInput,
|
|
1094
|
-
options?:
|
|
1098
|
+
options?: AthenaRequestOptions,
|
|
1095
1099
|
): Promise<UntagResourceCommandOutput>;
|
|
1096
1100
|
untagResource(
|
|
1097
1101
|
args: UntagResourceCommandInput,
|
|
@@ -1099,12 +1103,12 @@ export interface Athena {
|
|
|
1099
1103
|
): void;
|
|
1100
1104
|
untagResource(
|
|
1101
1105
|
args: UntagResourceCommandInput,
|
|
1102
|
-
options:
|
|
1106
|
+
options: AthenaRequestOptions,
|
|
1103
1107
|
cb: (err: any, data?: UntagResourceCommandOutput) => void,
|
|
1104
1108
|
): void;
|
|
1105
1109
|
updateCapacityReservation(
|
|
1106
1110
|
args: UpdateCapacityReservationCommandInput,
|
|
1107
|
-
options?:
|
|
1111
|
+
options?: AthenaRequestOptions,
|
|
1108
1112
|
): Promise<UpdateCapacityReservationCommandOutput>;
|
|
1109
1113
|
updateCapacityReservation(
|
|
1110
1114
|
args: UpdateCapacityReservationCommandInput,
|
|
@@ -1112,12 +1116,12 @@ export interface Athena {
|
|
|
1112
1116
|
): void;
|
|
1113
1117
|
updateCapacityReservation(
|
|
1114
1118
|
args: UpdateCapacityReservationCommandInput,
|
|
1115
|
-
options:
|
|
1119
|
+
options: AthenaRequestOptions,
|
|
1116
1120
|
cb: (err: any, data?: UpdateCapacityReservationCommandOutput) => void,
|
|
1117
1121
|
): void;
|
|
1118
1122
|
updateDataCatalog(
|
|
1119
1123
|
args: UpdateDataCatalogCommandInput,
|
|
1120
|
-
options?:
|
|
1124
|
+
options?: AthenaRequestOptions,
|
|
1121
1125
|
): Promise<UpdateDataCatalogCommandOutput>;
|
|
1122
1126
|
updateDataCatalog(
|
|
1123
1127
|
args: UpdateDataCatalogCommandInput,
|
|
@@ -1125,12 +1129,12 @@ export interface Athena {
|
|
|
1125
1129
|
): void;
|
|
1126
1130
|
updateDataCatalog(
|
|
1127
1131
|
args: UpdateDataCatalogCommandInput,
|
|
1128
|
-
options:
|
|
1132
|
+
options: AthenaRequestOptions,
|
|
1129
1133
|
cb: (err: any, data?: UpdateDataCatalogCommandOutput) => void,
|
|
1130
1134
|
): void;
|
|
1131
1135
|
updateNamedQuery(
|
|
1132
1136
|
args: UpdateNamedQueryCommandInput,
|
|
1133
|
-
options?:
|
|
1137
|
+
options?: AthenaRequestOptions,
|
|
1134
1138
|
): Promise<UpdateNamedQueryCommandOutput>;
|
|
1135
1139
|
updateNamedQuery(
|
|
1136
1140
|
args: UpdateNamedQueryCommandInput,
|
|
@@ -1138,12 +1142,12 @@ export interface Athena {
|
|
|
1138
1142
|
): void;
|
|
1139
1143
|
updateNamedQuery(
|
|
1140
1144
|
args: UpdateNamedQueryCommandInput,
|
|
1141
|
-
options:
|
|
1145
|
+
options: AthenaRequestOptions,
|
|
1142
1146
|
cb: (err: any, data?: UpdateNamedQueryCommandOutput) => void,
|
|
1143
1147
|
): void;
|
|
1144
1148
|
updateNotebook(
|
|
1145
1149
|
args: UpdateNotebookCommandInput,
|
|
1146
|
-
options?:
|
|
1150
|
+
options?: AthenaRequestOptions,
|
|
1147
1151
|
): Promise<UpdateNotebookCommandOutput>;
|
|
1148
1152
|
updateNotebook(
|
|
1149
1153
|
args: UpdateNotebookCommandInput,
|
|
@@ -1151,12 +1155,12 @@ export interface Athena {
|
|
|
1151
1155
|
): void;
|
|
1152
1156
|
updateNotebook(
|
|
1153
1157
|
args: UpdateNotebookCommandInput,
|
|
1154
|
-
options:
|
|
1158
|
+
options: AthenaRequestOptions,
|
|
1155
1159
|
cb: (err: any, data?: UpdateNotebookCommandOutput) => void,
|
|
1156
1160
|
): void;
|
|
1157
1161
|
updateNotebookMetadata(
|
|
1158
1162
|
args: UpdateNotebookMetadataCommandInput,
|
|
1159
|
-
options?:
|
|
1163
|
+
options?: AthenaRequestOptions,
|
|
1160
1164
|
): Promise<UpdateNotebookMetadataCommandOutput>;
|
|
1161
1165
|
updateNotebookMetadata(
|
|
1162
1166
|
args: UpdateNotebookMetadataCommandInput,
|
|
@@ -1164,12 +1168,12 @@ export interface Athena {
|
|
|
1164
1168
|
): void;
|
|
1165
1169
|
updateNotebookMetadata(
|
|
1166
1170
|
args: UpdateNotebookMetadataCommandInput,
|
|
1167
|
-
options:
|
|
1171
|
+
options: AthenaRequestOptions,
|
|
1168
1172
|
cb: (err: any, data?: UpdateNotebookMetadataCommandOutput) => void,
|
|
1169
1173
|
): void;
|
|
1170
1174
|
updatePreparedStatement(
|
|
1171
1175
|
args: UpdatePreparedStatementCommandInput,
|
|
1172
|
-
options?:
|
|
1176
|
+
options?: AthenaRequestOptions,
|
|
1173
1177
|
): Promise<UpdatePreparedStatementCommandOutput>;
|
|
1174
1178
|
updatePreparedStatement(
|
|
1175
1179
|
args: UpdatePreparedStatementCommandInput,
|
|
@@ -1177,12 +1181,12 @@ export interface Athena {
|
|
|
1177
1181
|
): void;
|
|
1178
1182
|
updatePreparedStatement(
|
|
1179
1183
|
args: UpdatePreparedStatementCommandInput,
|
|
1180
|
-
options:
|
|
1184
|
+
options: AthenaRequestOptions,
|
|
1181
1185
|
cb: (err: any, data?: UpdatePreparedStatementCommandOutput) => void,
|
|
1182
1186
|
): void;
|
|
1183
1187
|
updateWorkGroup(
|
|
1184
1188
|
args: UpdateWorkGroupCommandInput,
|
|
1185
|
-
options?:
|
|
1189
|
+
options?: AthenaRequestOptions,
|
|
1186
1190
|
): Promise<UpdateWorkGroupCommandOutput>;
|
|
1187
1191
|
updateWorkGroup(
|
|
1188
1192
|
args: UpdateWorkGroupCommandInput,
|
|
@@ -1190,7 +1194,7 @@ export interface Athena {
|
|
|
1190
1194
|
): void;
|
|
1191
1195
|
updateWorkGroup(
|
|
1192
1196
|
args: UpdateWorkGroupCommandInput,
|
|
1193
|
-
options:
|
|
1197
|
+
options: AthenaRequestOptions,
|
|
1194
1198
|
cb: (err: any, data?: UpdateWorkGroupCommandOutput) => void,
|
|
1195
1199
|
): void;
|
|
1196
1200
|
paginateGetQueryResults(
|