aws-sdk 2.1367.0 → 2.1368.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 +11 -1
- package/README.md +1 -1
- package/apis/appflow-2020-08-23.min.json +104 -93
- package/apis/athena-2017-05-18.min.json +259 -50
- package/apis/athena-2017-05-18.paginators.json +5 -0
- package/apis/grafana-2020-08-18.min.json +1 -0
- package/apis/iot-2015-05-28.min.json +289 -274
- package/apis/rekognition-2016-06-27.min.json +112 -48
- package/apis/simspaceweaver-2022-10-28.min.json +52 -16
- package/clients/appflow.d.ts +14 -1
- package/clients/athena.d.ts +228 -10
- package/clients/directconnect.d.ts +2 -2
- package/clients/efs.d.ts +1 -1
- package/clients/grafana.d.ts +4 -0
- package/clients/iot.d.ts +21 -2
- package/clients/rekognition.d.ts +117 -0
- package/clients/simspaceweaver.d.ts +62 -21
- package/clients/wafv2.d.ts +57 -57
- package/clients/workspaces.d.ts +3 -3
- package/dist/aws-sdk-core-react-native.js +1 -1
- package/dist/aws-sdk-react-native.js +8 -8
- package/dist/aws-sdk.js +668 -375
- package/dist/aws-sdk.min.js +98 -98
- package/lib/core.js +1 -1
- package/package.json +1 -1
    
        package/clients/athena.d.ts
    CHANGED
    
    | @@ -35,6 +35,22 @@ declare class Athena extends Service { | |
| 35 35 | 
             
               * Returns the details of a single query execution or a list of up to 50 query executions, which you provide as an array of query execution ID strings. Requires you to have access to the workgroup in which the queries ran. To get a list of query execution IDs, use ListQueryExecutionsInput$WorkGroup. Query executions differ from named (saved) queries. Use BatchGetNamedQueryInput to get details about named queries.
         | 
| 36 36 | 
             
               */
         | 
| 37 37 | 
             
              batchGetQueryExecution(callback?: (err: AWSError, data: Athena.Types.BatchGetQueryExecutionOutput) => void): Request<Athena.Types.BatchGetQueryExecutionOutput, AWSError>;
         | 
| 38 | 
            +
              /**
         | 
| 39 | 
            +
               * Cancels the capacity reservation with the specified name.
         | 
| 40 | 
            +
               */
         | 
| 41 | 
            +
              cancelCapacityReservation(params: Athena.Types.CancelCapacityReservationInput, callback?: (err: AWSError, data: Athena.Types.CancelCapacityReservationOutput) => void): Request<Athena.Types.CancelCapacityReservationOutput, AWSError>;
         | 
| 42 | 
            +
              /**
         | 
| 43 | 
            +
               * Cancels the capacity reservation with the specified name.
         | 
| 44 | 
            +
               */
         | 
| 45 | 
            +
              cancelCapacityReservation(callback?: (err: AWSError, data: Athena.Types.CancelCapacityReservationOutput) => void): Request<Athena.Types.CancelCapacityReservationOutput, AWSError>;
         | 
| 46 | 
            +
              /**
         | 
| 47 | 
            +
               * Creates a capacity reservation with the specified name and number of requested data processing units.
         | 
| 48 | 
            +
               */
         | 
| 49 | 
            +
              createCapacityReservation(params: Athena.Types.CreateCapacityReservationInput, callback?: (err: AWSError, data: Athena.Types.CreateCapacityReservationOutput) => void): Request<Athena.Types.CreateCapacityReservationOutput, AWSError>;
         | 
| 50 | 
            +
              /**
         | 
| 51 | 
            +
               * Creates a capacity reservation with the specified name and number of requested data processing units.
         | 
| 52 | 
            +
               */
         | 
| 53 | 
            +
              createCapacityReservation(callback?: (err: AWSError, data: Athena.Types.CreateCapacityReservationOutput) => void): Request<Athena.Types.CreateCapacityReservationOutput, AWSError>;
         | 
| 38 54 | 
             
              /**
         | 
| 39 55 | 
             
               * Creates (registers) a data catalog with the specified name and properties. Catalogs created are visible to all users of the same Amazon Web Services account.
         | 
| 40 56 | 
             
               */
         | 
| @@ -155,6 +171,22 @@ declare class Athena extends Service { | |
| 155 171 | 
             
               * Gets the status of a current calculation.
         | 
| 156 172 | 
             
               */
         | 
| 157 173 | 
             
              getCalculationExecutionStatus(callback?: (err: AWSError, data: Athena.Types.GetCalculationExecutionStatusResponse) => void): Request<Athena.Types.GetCalculationExecutionStatusResponse, AWSError>;
         | 
| 174 | 
            +
              /**
         | 
| 175 | 
            +
               * Gets the capacity assignment configuration for a capacity reservation, if one exists.
         | 
| 176 | 
            +
               */
         | 
| 177 | 
            +
              getCapacityAssignmentConfiguration(params: Athena.Types.GetCapacityAssignmentConfigurationInput, callback?: (err: AWSError, data: Athena.Types.GetCapacityAssignmentConfigurationOutput) => void): Request<Athena.Types.GetCapacityAssignmentConfigurationOutput, AWSError>;
         | 
| 178 | 
            +
              /**
         | 
| 179 | 
            +
               * Gets the capacity assignment configuration for a capacity reservation, if one exists.
         | 
| 180 | 
            +
               */
         | 
| 181 | 
            +
              getCapacityAssignmentConfiguration(callback?: (err: AWSError, data: Athena.Types.GetCapacityAssignmentConfigurationOutput) => void): Request<Athena.Types.GetCapacityAssignmentConfigurationOutput, AWSError>;
         | 
| 182 | 
            +
              /**
         | 
| 183 | 
            +
               * Returns information about the capacity reservation with the specified name.
         | 
| 184 | 
            +
               */
         | 
| 185 | 
            +
              getCapacityReservation(params: Athena.Types.GetCapacityReservationInput, callback?: (err: AWSError, data: Athena.Types.GetCapacityReservationOutput) => void): Request<Athena.Types.GetCapacityReservationOutput, AWSError>;
         | 
| 186 | 
            +
              /**
         | 
| 187 | 
            +
               * Returns information about the capacity reservation with the specified name.
         | 
| 188 | 
            +
               */
         | 
| 189 | 
            +
              getCapacityReservation(callback?: (err: AWSError, data: Athena.Types.GetCapacityReservationOutput) => void): Request<Athena.Types.GetCapacityReservationOutput, AWSError>;
         | 
| 158 190 | 
             
              /**
         | 
| 159 191 | 
             
               * Returns the specified data catalog.
         | 
| 160 192 | 
             
               */
         | 
| @@ -275,6 +307,14 @@ declare class Athena extends Service { | |
| 275 307 | 
             
               * Lists the calculations that have been submitted to a session in descending order. Newer calculations are listed first; older calculations are listed later.
         | 
| 276 308 | 
             
               */
         | 
| 277 309 | 
             
              listCalculationExecutions(callback?: (err: AWSError, data: Athena.Types.ListCalculationExecutionsResponse) => void): Request<Athena.Types.ListCalculationExecutionsResponse, AWSError>;
         | 
| 310 | 
            +
              /**
         | 
| 311 | 
            +
               * Lists the capacity reservations for the current account.
         | 
| 312 | 
            +
               */
         | 
| 313 | 
            +
              listCapacityReservations(params: Athena.Types.ListCapacityReservationsInput, callback?: (err: AWSError, data: Athena.Types.ListCapacityReservationsOutput) => void): Request<Athena.Types.ListCapacityReservationsOutput, AWSError>;
         | 
| 314 | 
            +
              /**
         | 
| 315 | 
            +
               * Lists the capacity reservations for the current account.
         | 
| 316 | 
            +
               */
         | 
| 317 | 
            +
              listCapacityReservations(callback?: (err: AWSError, data: Athena.Types.ListCapacityReservationsOutput) => void): Request<Athena.Types.ListCapacityReservationsOutput, AWSError>;
         | 
| 278 318 | 
             
              /**
         | 
| 279 319 | 
             
               * Lists the data catalogs in the current Amazon Web Services account.  In the Athena console, data catalogs are listed as "data sources" on the Data sources page under the Data source name column. 
         | 
| 280 320 | 
             
               */
         | 
| @@ -364,11 +404,11 @@ declare class Athena extends Service { | |
| 364 404 | 
             
               */
         | 
| 365 405 | 
             
              listTableMetadata(callback?: (err: AWSError, data: Athena.Types.ListTableMetadataOutput) => void): Request<Athena.Types.ListTableMetadataOutput, AWSError>;
         | 
| 366 406 | 
             
              /**
         | 
| 367 | 
            -
               * Lists the tags associated with an Athena  | 
| 407 | 
            +
               * Lists the tags associated with an Athena resource.
         | 
| 368 408 | 
             
               */
         | 
| 369 409 | 
             
              listTagsForResource(params: Athena.Types.ListTagsForResourceInput, callback?: (err: AWSError, data: Athena.Types.ListTagsForResourceOutput) => void): Request<Athena.Types.ListTagsForResourceOutput, AWSError>;
         | 
| 370 410 | 
             
              /**
         | 
| 371 | 
            -
               * Lists the tags associated with an Athena  | 
| 411 | 
            +
               * Lists the tags associated with an Athena resource.
         | 
| 372 412 | 
             
               */
         | 
| 373 413 | 
             
              listTagsForResource(callback?: (err: AWSError, data: Athena.Types.ListTagsForResourceOutput) => void): Request<Athena.Types.ListTagsForResourceOutput, AWSError>;
         | 
| 374 414 | 
             
              /**
         | 
| @@ -379,6 +419,14 @@ declare class Athena extends Service { | |
| 379 419 | 
             
               * Lists available workgroups for the account.
         | 
| 380 420 | 
             
               */
         | 
| 381 421 | 
             
              listWorkGroups(callback?: (err: AWSError, data: Athena.Types.ListWorkGroupsOutput) => void): Request<Athena.Types.ListWorkGroupsOutput, AWSError>;
         | 
| 422 | 
            +
              /**
         | 
| 423 | 
            +
               * Puts a new capacity assignment configuration for a specified capacity reservation. If a capacity assignment configuration already exists for the capacity reservation, replaces the existing capacity assignment configuration.
         | 
| 424 | 
            +
               */
         | 
| 425 | 
            +
              putCapacityAssignmentConfiguration(params: Athena.Types.PutCapacityAssignmentConfigurationInput, callback?: (err: AWSError, data: Athena.Types.PutCapacityAssignmentConfigurationOutput) => void): Request<Athena.Types.PutCapacityAssignmentConfigurationOutput, AWSError>;
         | 
| 426 | 
            +
              /**
         | 
| 427 | 
            +
               * Puts a new capacity assignment configuration for a specified capacity reservation. If a capacity assignment configuration already exists for the capacity reservation, replaces the existing capacity assignment configuration.
         | 
| 428 | 
            +
               */
         | 
| 429 | 
            +
              putCapacityAssignmentConfiguration(callback?: (err: AWSError, data: Athena.Types.PutCapacityAssignmentConfigurationOutput) => void): Request<Athena.Types.PutCapacityAssignmentConfigurationOutput, AWSError>;
         | 
| 382 430 | 
             
              /**
         | 
| 383 431 | 
             
               * Submits calculations for execution within a session. You can supply the code to run as an inline code block within the request.
         | 
| 384 432 | 
             
               */
         | 
| @@ -420,11 +468,11 @@ declare class Athena extends Service { | |
| 420 468 | 
             
               */
         | 
| 421 469 | 
             
              stopQueryExecution(callback?: (err: AWSError, data: Athena.Types.StopQueryExecutionOutput) => void): Request<Athena.Types.StopQueryExecutionOutput, AWSError>;
         | 
| 422 470 | 
             
              /**
         | 
| 423 | 
            -
               * Adds one or more tags to an Athena resource. A tag is a label that you assign to a resource.  | 
| 471 | 
            +
               * Adds one or more tags to an Athena resource. A tag is a label that you assign to a resource. Each tag consists of a key and an optional value, both of which you define. For example, you can use tags to categorize Athena workgroups, data catalogs, or capacity reservations by purpose, owner, or environment. Use a consistent set of tag keys to make it easier to search and filter the resources in your account. For best practices, see Tagging Best Practices. Tag keys can be from 1 to 128 UTF-8 Unicode characters, and tag values can be from 0 to 256 UTF-8 Unicode characters. Tags can use letters and numbers representable in UTF-8, and the following characters: + - = . _ : / @. Tag keys and values are case-sensitive. Tag keys must be unique per resource. If you specify more than one tag, separate them by commas.
         | 
| 424 472 | 
             
               */
         | 
| 425 473 | 
             
              tagResource(params: Athena.Types.TagResourceInput, callback?: (err: AWSError, data: Athena.Types.TagResourceOutput) => void): Request<Athena.Types.TagResourceOutput, AWSError>;
         | 
| 426 474 | 
             
              /**
         | 
| 427 | 
            -
               * Adds one or more tags to an Athena resource. A tag is a label that you assign to a resource.  | 
| 475 | 
            +
               * Adds one or more tags to an Athena resource. A tag is a label that you assign to a resource. Each tag consists of a key and an optional value, both of which you define. For example, you can use tags to categorize Athena workgroups, data catalogs, or capacity reservations by purpose, owner, or environment. Use a consistent set of tag keys to make it easier to search and filter the resources in your account. For best practices, see Tagging Best Practices. Tag keys can be from 1 to 128 UTF-8 Unicode characters, and tag values can be from 0 to 256 UTF-8 Unicode characters. Tags can use letters and numbers representable in UTF-8, and the following characters: + - = . _ : / @. Tag keys and values are case-sensitive. Tag keys must be unique per resource. If you specify more than one tag, separate them by commas.
         | 
| 428 476 | 
             
               */
         | 
| 429 477 | 
             
              tagResource(callback?: (err: AWSError, data: Athena.Types.TagResourceOutput) => void): Request<Athena.Types.TagResourceOutput, AWSError>;
         | 
| 430 478 | 
             
              /**
         | 
| @@ -436,13 +484,21 @@ declare class Athena extends Service { | |
| 436 484 | 
             
               */
         | 
| 437 485 | 
             
              terminateSession(callback?: (err: AWSError, data: Athena.Types.TerminateSessionResponse) => void): Request<Athena.Types.TerminateSessionResponse, AWSError>;
         | 
| 438 486 | 
             
              /**
         | 
| 439 | 
            -
               * Removes one or more tags from  | 
| 487 | 
            +
               * Removes one or more tags from an Athena resource.
         | 
| 440 488 | 
             
               */
         | 
| 441 489 | 
             
              untagResource(params: Athena.Types.UntagResourceInput, callback?: (err: AWSError, data: Athena.Types.UntagResourceOutput) => void): Request<Athena.Types.UntagResourceOutput, AWSError>;
         | 
| 442 490 | 
             
              /**
         | 
| 443 | 
            -
               * Removes one or more tags from  | 
| 491 | 
            +
               * Removes one or more tags from an Athena resource.
         | 
| 444 492 | 
             
               */
         | 
| 445 493 | 
             
              untagResource(callback?: (err: AWSError, data: Athena.Types.UntagResourceOutput) => void): Request<Athena.Types.UntagResourceOutput, AWSError>;
         | 
| 494 | 
            +
              /**
         | 
| 495 | 
            +
               * Updates the number of requested data processing units for the capacity reservation with the specified name.
         | 
| 496 | 
            +
               */
         | 
| 497 | 
            +
              updateCapacityReservation(params: Athena.Types.UpdateCapacityReservationInput, callback?: (err: AWSError, data: Athena.Types.UpdateCapacityReservationOutput) => void): Request<Athena.Types.UpdateCapacityReservationOutput, AWSError>;
         | 
| 498 | 
            +
              /**
         | 
| 499 | 
            +
               * Updates the number of requested data processing units for the capacity reservation with the specified name.
         | 
| 500 | 
            +
               */
         | 
| 501 | 
            +
              updateCapacityReservation(callback?: (err: AWSError, data: Athena.Types.UpdateCapacityReservationOutput) => void): Request<Athena.Types.UpdateCapacityReservationOutput, AWSError>;
         | 
| 446 502 | 
             
              /**
         | 
| 447 503 | 
             
               * Updates the data catalog that has the specified name.
         | 
| 448 504 | 
             
               */
         | 
| @@ -500,6 +556,7 @@ declare namespace Athena { | |
| 500 556 | 
             
                S3AclOption: S3AclOption;
         | 
| 501 557 | 
             
              }
         | 
| 502 558 | 
             
              export type Age = number;
         | 
| 559 | 
            +
              export type AllocatedDpusInteger = number;
         | 
| 503 560 | 
             
              export type AmazonResourceName = string;
         | 
| 504 561 | 
             
              export interface ApplicationDPUSizes {
         | 
| 505 562 | 
             
                /**
         | 
| @@ -657,6 +714,80 @@ declare namespace Athena { | |
| 657 714 | 
             
                Status?: CalculationStatus;
         | 
| 658 715 | 
             
              }
         | 
| 659 716 | 
             
              export type CalculationsList = CalculationSummary[];
         | 
| 717 | 
            +
              export interface CancelCapacityReservationInput {
         | 
| 718 | 
            +
                /**
         | 
| 719 | 
            +
                 * The name of the capacity reservation to cancel.
         | 
| 720 | 
            +
                 */
         | 
| 721 | 
            +
                Name: CapacityReservationName;
         | 
| 722 | 
            +
              }
         | 
| 723 | 
            +
              export interface CancelCapacityReservationOutput {
         | 
| 724 | 
            +
              }
         | 
| 725 | 
            +
              export interface CapacityAllocation {
         | 
| 726 | 
            +
                /**
         | 
| 727 | 
            +
                 * The status of the capacity allocation.
         | 
| 728 | 
            +
                 */
         | 
| 729 | 
            +
                Status: CapacityAllocationStatus;
         | 
| 730 | 
            +
                /**
         | 
| 731 | 
            +
                 * The status message of the capacity allocation.
         | 
| 732 | 
            +
                 */
         | 
| 733 | 
            +
                StatusMessage?: String;
         | 
| 734 | 
            +
                /**
         | 
| 735 | 
            +
                 * The time when the capacity allocation was requested.
         | 
| 736 | 
            +
                 */
         | 
| 737 | 
            +
                RequestTime: Timestamp;
         | 
| 738 | 
            +
                /**
         | 
| 739 | 
            +
                 * The time when the capacity allocation request was completed.
         | 
| 740 | 
            +
                 */
         | 
| 741 | 
            +
                RequestCompletionTime?: Timestamp;
         | 
| 742 | 
            +
              }
         | 
| 743 | 
            +
              export type CapacityAllocationStatus = "PENDING"|"SUCCEEDED"|"FAILED"|string;
         | 
| 744 | 
            +
              export interface CapacityAssignment {
         | 
| 745 | 
            +
                /**
         | 
| 746 | 
            +
                 * The list of workgroup names for the capacity assignment.
         | 
| 747 | 
            +
                 */
         | 
| 748 | 
            +
                WorkGroupNames?: WorkGroupNamesList;
         | 
| 749 | 
            +
              }
         | 
| 750 | 
            +
              export interface CapacityAssignmentConfiguration {
         | 
| 751 | 
            +
                /**
         | 
| 752 | 
            +
                 * The name of the reservation that the capacity assignment configuration is for.
         | 
| 753 | 
            +
                 */
         | 
| 754 | 
            +
                CapacityReservationName?: CapacityReservationName;
         | 
| 755 | 
            +
                /**
         | 
| 756 | 
            +
                 * The list of assignments that make up the capacity assignment configuration.
         | 
| 757 | 
            +
                 */
         | 
| 758 | 
            +
                CapacityAssignments?: CapacityAssignmentsList;
         | 
| 759 | 
            +
              }
         | 
| 760 | 
            +
              export type CapacityAssignmentsList = CapacityAssignment[];
         | 
| 761 | 
            +
              export interface CapacityReservation {
         | 
| 762 | 
            +
                /**
         | 
| 763 | 
            +
                 * The name of the capacity reservation.
         | 
| 764 | 
            +
                 */
         | 
| 765 | 
            +
                Name: CapacityReservationName;
         | 
| 766 | 
            +
                /**
         | 
| 767 | 
            +
                 * The status of the capacity reservation.
         | 
| 768 | 
            +
                 */
         | 
| 769 | 
            +
                Status: CapacityReservationStatus;
         | 
| 770 | 
            +
                /**
         | 
| 771 | 
            +
                 * The number of data processing units requested.
         | 
| 772 | 
            +
                 */
         | 
| 773 | 
            +
                TargetDpus: TargetDpusInteger;
         | 
| 774 | 
            +
                /**
         | 
| 775 | 
            +
                 * The number of data processing units currently allocated.
         | 
| 776 | 
            +
                 */
         | 
| 777 | 
            +
                AllocatedDpus: AllocatedDpusInteger;
         | 
| 778 | 
            +
                LastAllocation?: CapacityAllocation;
         | 
| 779 | 
            +
                /**
         | 
| 780 | 
            +
                 * The time of the most recent capacity allocation that succeeded.
         | 
| 781 | 
            +
                 */
         | 
| 782 | 
            +
                LastSuccessfulAllocationTime?: Timestamp;
         | 
| 783 | 
            +
                /**
         | 
| 784 | 
            +
                 * The time in UTC epoch millis when the capacity reservation was created.
         | 
| 785 | 
            +
                 */
         | 
| 786 | 
            +
                CreationTime: Timestamp;
         | 
| 787 | 
            +
              }
         | 
| 788 | 
            +
              export type CapacityReservationName = string;
         | 
| 789 | 
            +
              export type CapacityReservationStatus = "PENDING"|"ACTIVE"|"CANCELLING"|"CANCELLED"|"FAILED"|"UPDATE_PENDING"|string;
         | 
| 790 | 
            +
              export type CapacityReservationsList = CapacityReservation[];
         | 
| 660 791 | 
             
              export type CatalogNameString = string;
         | 
| 661 792 | 
             
              export type ClientRequestToken = string;
         | 
| 662 793 | 
             
              export type CodeBlock = string;
         | 
| @@ -721,6 +852,22 @@ declare namespace Athena { | |
| 721 852 | 
             
              export type ColumnNullable = "NOT_NULL"|"NULLABLE"|"UNKNOWN"|string;
         | 
| 722 853 | 
             
              export type CommentString = string;
         | 
| 723 854 | 
             
              export type CoordinatorDpuSize = number;
         | 
| 855 | 
            +
              export interface CreateCapacityReservationInput {
         | 
| 856 | 
            +
                /**
         | 
| 857 | 
            +
                 * The number of requested data processing units.
         | 
| 858 | 
            +
                 */
         | 
| 859 | 
            +
                TargetDpus: TargetDpusInteger;
         | 
| 860 | 
            +
                /**
         | 
| 861 | 
            +
                 * The name of the capacity reservation to create.
         | 
| 862 | 
            +
                 */
         | 
| 863 | 
            +
                Name: CapacityReservationName;
         | 
| 864 | 
            +
                /**
         | 
| 865 | 
            +
                 * The tags for the capacity reservation.
         | 
| 866 | 
            +
                 */
         | 
| 867 | 
            +
                Tags?: TagList;
         | 
| 868 | 
            +
              }
         | 
| 869 | 
            +
              export interface CreateCapacityReservationOutput {
         | 
| 870 | 
            +
              }
         | 
| 724 871 | 
             
              export interface CreateDataCatalogInput {
         | 
| 725 872 | 
             
                /**
         | 
| 726 873 | 
             
                 * The name of the data catalog to create. The catalog name must be unique for the Amazon Web Services account and can use a maximum of 127 alphanumeric, underscore, at sign, or hyphen characters. The remainder of the length constraint of 256 is reserved for use by Athena.
         | 
| @@ -979,7 +1126,7 @@ declare namespace Athena { | |
| 979 1126 | 
             
              export type EncryptionOption = "SSE_S3"|"SSE_KMS"|"CSE_KMS"|string;
         | 
| 980 1127 | 
             
              export interface EngineConfiguration {
         | 
| 981 1128 | 
             
                /**
         | 
| 982 | 
            -
                 * The number of DPUs to use for the coordinator. A coordinator is a special executor that orchestrates processing work and manages other executors in a notebook session.
         | 
| 1129 | 
            +
                 * The number of DPUs to use for the coordinator. A coordinator is a special executor that orchestrates processing work and manages other executors in a notebook session. The default is 1.
         | 
| 983 1130 | 
             
                 */
         | 
| 984 1131 | 
             
                CoordinatorDpuSize?: CoordinatorDpuSize;
         | 
| 985 1132 | 
             
                /**
         | 
| @@ -987,7 +1134,7 @@ declare namespace Athena { | |
| 987 1134 | 
             
                 */
         | 
| 988 1135 | 
             
                MaxConcurrentDpus: MaxConcurrentDpus;
         | 
| 989 1136 | 
             
                /**
         | 
| 990 | 
            -
                 * The default number of DPUs to use for executors. An executor is the smallest unit of compute that a notebook session can request from Athena.
         | 
| 1137 | 
            +
                 * The default number of DPUs to use for executors. An executor is the smallest unit of compute that a notebook session can request from Athena. The default is 1.
         | 
| 991 1138 | 
             
                 */
         | 
| 992 1139 | 
             
                DefaultExecutorDpuSize?: DefaultExecutorDpuSize;
         | 
| 993 1140 | 
             
                /**
         | 
| @@ -1129,6 +1276,30 @@ declare namespace Athena { | |
| 1129 1276 | 
             
                 */
         | 
| 1130 1277 | 
             
                Statistics?: CalculationStatistics;
         | 
| 1131 1278 | 
             
              }
         | 
| 1279 | 
            +
              export interface GetCapacityAssignmentConfigurationInput {
         | 
| 1280 | 
            +
                /**
         | 
| 1281 | 
            +
                 * The name of the capacity reservation to retrieve the capacity assignment configuration for.
         | 
| 1282 | 
            +
                 */
         | 
| 1283 | 
            +
                CapacityReservationName: CapacityReservationName;
         | 
| 1284 | 
            +
              }
         | 
| 1285 | 
            +
              export interface GetCapacityAssignmentConfigurationOutput {
         | 
| 1286 | 
            +
                /**
         | 
| 1287 | 
            +
                 * The requested capacity assignment configuration for the specified capacity reservation.
         | 
| 1288 | 
            +
                 */
         | 
| 1289 | 
            +
                CapacityAssignmentConfiguration: CapacityAssignmentConfiguration;
         | 
| 1290 | 
            +
              }
         | 
| 1291 | 
            +
              export interface GetCapacityReservationInput {
         | 
| 1292 | 
            +
                /**
         | 
| 1293 | 
            +
                 * The name of the capacity reservation.
         | 
| 1294 | 
            +
                 */
         | 
| 1295 | 
            +
                Name: CapacityReservationName;
         | 
| 1296 | 
            +
              }
         | 
| 1297 | 
            +
              export interface GetCapacityReservationOutput {
         | 
| 1298 | 
            +
                /**
         | 
| 1299 | 
            +
                 * The requested capacity reservation structure.
         | 
| 1300 | 
            +
                 */
         | 
| 1301 | 
            +
                CapacityReservation: CapacityReservation;
         | 
| 1302 | 
            +
              }
         | 
| 1132 1303 | 
             
              export interface GetDataCatalogInput {
         | 
| 1133 1304 | 
             
                /**
         | 
| 1134 1305 | 
             
                 * The name of the data catalog to return.
         | 
| @@ -1421,6 +1592,26 @@ declare namespace Athena { | |
| 1421 1592 | 
             
                 */
         | 
| 1422 1593 | 
             
                Calculations?: CalculationsList;
         | 
| 1423 1594 | 
             
              }
         | 
| 1595 | 
            +
              export interface ListCapacityReservationsInput {
         | 
| 1596 | 
            +
                /**
         | 
| 1597 | 
            +
                 * A token generated by the Athena service that specifies where to continue pagination if a previous request was truncated.
         | 
| 1598 | 
            +
                 */
         | 
| 1599 | 
            +
                NextToken?: Token;
         | 
| 1600 | 
            +
                /**
         | 
| 1601 | 
            +
                 * Specifies the maximum number of results to return.
         | 
| 1602 | 
            +
                 */
         | 
| 1603 | 
            +
                MaxResults?: MaxCapacityReservationsCount;
         | 
| 1604 | 
            +
              }
         | 
| 1605 | 
            +
              export interface ListCapacityReservationsOutput {
         | 
| 1606 | 
            +
                /**
         | 
| 1607 | 
            +
                 * A token generated by the Athena service that specifies where to continue pagination if a previous request was truncated. To obtain the next set of pages, pass in the NextToken from the response object of the previous page call.
         | 
| 1608 | 
            +
                 */
         | 
| 1609 | 
            +
                NextToken?: Token;
         | 
| 1610 | 
            +
                /**
         | 
| 1611 | 
            +
                 * The capacity reservations for the current account.
         | 
| 1612 | 
            +
                 */
         | 
| 1613 | 
            +
                CapacityReservations: CapacityReservationsList;
         | 
| 1614 | 
            +
              }
         | 
| 1424 1615 | 
             
              export interface ListDataCatalogsInput {
         | 
| 1425 1616 | 
             
                /**
         | 
| 1426 1617 | 
             
                 * A token generated by the Athena service that specifies where to continue pagination if a previous request was truncated. To obtain the next set of pages, pass in the NextToken from the response object of the previous page call.
         | 
| @@ -1748,6 +1939,7 @@ declare namespace Athena { | |
| 1748 1939 | 
             
              export type Long = number;
         | 
| 1749 1940 | 
             
              export type MaxApplicationDPUSizesCount = number;
         | 
| 1750 1941 | 
             
              export type MaxCalculationsCount = number;
         | 
| 1942 | 
            +
              export type MaxCapacityReservationsCount = number;
         | 
| 1751 1943 | 
             
              export type MaxConcurrentDpus = number;
         | 
| 1752 1944 | 
             
              export type MaxDataCatalogsCount = number;
         | 
| 1753 1945 | 
             
              export type MaxDatabasesCount = number;
         | 
| @@ -1872,6 +2064,18 @@ declare namespace Athena { | |
| 1872 2064 | 
             
                LastModifiedTime?: _Date;
         | 
| 1873 2065 | 
             
              }
         | 
| 1874 2066 | 
             
              export type PreparedStatementsList = PreparedStatementSummary[];
         | 
| 2067 | 
            +
              export interface PutCapacityAssignmentConfigurationInput {
         | 
| 2068 | 
            +
                /**
         | 
| 2069 | 
            +
                 * The name of the capacity reservation to put a capacity assignment configuration for.
         | 
| 2070 | 
            +
                 */
         | 
| 2071 | 
            +
                CapacityReservationName: CapacityReservationName;
         | 
| 2072 | 
            +
                /**
         | 
| 2073 | 
            +
                 * The list of assignments for the capacity assignment configuration.
         | 
| 2074 | 
            +
                 */
         | 
| 2075 | 
            +
                CapacityAssignments: CapacityAssignmentsList;
         | 
| 2076 | 
            +
              }
         | 
| 2077 | 
            +
              export interface PutCapacityAssignmentConfigurationOutput {
         | 
| 2078 | 
            +
              }
         | 
| 1875 2079 | 
             
              export interface QueryExecution {
         | 
| 1876 2080 | 
             
                /**
         | 
| 1877 2081 | 
             
                 * The unique identifier for each query execution.
         | 
| @@ -2450,17 +2654,18 @@ declare namespace Athena { | |
| 2450 2654 | 
             
              export type TagList = Tag[];
         | 
| 2451 2655 | 
             
              export interface TagResourceInput {
         | 
| 2452 2656 | 
             
                /**
         | 
| 2453 | 
            -
                 * Specifies the ARN of the Athena resource  | 
| 2657 | 
            +
                 * Specifies the ARN of the Athena resource to which tags are to be added.
         | 
| 2454 2658 | 
             
                 */
         | 
| 2455 2659 | 
             
                ResourceARN: AmazonResourceName;
         | 
| 2456 2660 | 
             
                /**
         | 
| 2457 | 
            -
                 * A collection of one or more tags, separated by commas, to be added to an Athena  | 
| 2661 | 
            +
                 * A collection of one or more tags, separated by commas, to be added to an Athena resource.
         | 
| 2458 2662 | 
             
                 */
         | 
| 2459 2663 | 
             
                Tags: TagList;
         | 
| 2460 2664 | 
             
              }
         | 
| 2461 2665 | 
             
              export interface TagResourceOutput {
         | 
| 2462 2666 | 
             
              }
         | 
| 2463 2667 | 
             
              export type TagValue = string;
         | 
| 2668 | 
            +
              export type TargetDpusInteger = number;
         | 
| 2464 2669 | 
             
              export interface TerminateSessionRequest {
         | 
| 2465 2670 | 
             
                /**
         | 
| 2466 2671 | 
             
                 * The session ID.
         | 
| @@ -2533,6 +2738,18 @@ declare namespace Athena { | |
| 2533 2738 | 
             
              }
         | 
| 2534 2739 | 
             
              export interface UntagResourceOutput {
         | 
| 2535 2740 | 
             
              }
         | 
| 2741 | 
            +
              export interface UpdateCapacityReservationInput {
         | 
| 2742 | 
            +
                /**
         | 
| 2743 | 
            +
                 * The new number of requested data processing units.
         | 
| 2744 | 
            +
                 */
         | 
| 2745 | 
            +
                TargetDpus: TargetDpusInteger;
         | 
| 2746 | 
            +
                /**
         | 
| 2747 | 
            +
                 * The name of the capacity reservation.
         | 
| 2748 | 
            +
                 */
         | 
| 2749 | 
            +
                Name: CapacityReservationName;
         | 
| 2750 | 
            +
              }
         | 
| 2751 | 
            +
              export interface UpdateCapacityReservationOutput {
         | 
| 2752 | 
            +
              }
         | 
| 2536 2753 | 
             
              export interface UpdateDataCatalogInput {
         | 
| 2537 2754 | 
             
                /**
         | 
| 2538 2755 | 
             
                 * The name of the data catalog to update. The catalog name must be unique for the Amazon Web Services account and can use a maximum of 127 alphanumeric, underscore, at sign, or hyphen characters. The remainder of the length constraint of 256 is reserved for use by Athena.
         | 
| @@ -2766,6 +2983,7 @@ declare namespace Athena { | |
| 2766 2983 | 
             
              }
         | 
| 2767 2984 | 
             
              export type WorkGroupDescriptionString = string;
         | 
| 2768 2985 | 
             
              export type WorkGroupName = string;
         | 
| 2986 | 
            +
              export type WorkGroupNamesList = WorkGroupName[];
         | 
| 2769 2987 | 
             
              export type WorkGroupState = "ENABLED"|"DISABLED"|string;
         | 
| 2770 2988 | 
             
              export interface WorkGroupSummary {
         | 
| 2771 2989 | 
             
                /**
         | 
| @@ -1074,7 +1074,7 @@ declare namespace DirectConnect { | |
| 1074 1074 | 
             
              }
         | 
| 1075 1075 | 
             
              export interface CreateLagRequest {
         | 
| 1076 1076 | 
             
                /**
         | 
| 1077 | 
            -
                 * The number of physical dedicated connections initially provisioned and bundled by the LAG.
         | 
| 1077 | 
            +
                 * The number of physical dedicated connections initially provisioned and bundled by the LAG. You can have a maximum of four connections when the port speed is 1G or 10G, or two when the port speed is 100G. 
         | 
| 1078 1078 | 
             
                 */
         | 
| 1079 1079 | 
             
                numberOfConnections: Count;
         | 
| 1080 1080 | 
             
                /**
         | 
| @@ -2177,7 +2177,7 @@ declare namespace DirectConnect { | |
| 2177 2177 | 
             
                 */
         | 
| 2178 2178 | 
             
                asn?: ASN;
         | 
| 2179 2179 | 
             
                /**
         | 
| 2180 | 
            -
                 * The maximum transmission unit (MTU), in bytes. The supported values are 1500 and  | 
| 2180 | 
            +
                 * The maximum transmission unit (MTU), in bytes. The supported values are 1500 and 8500. The default value is 1500.
         | 
| 2181 2181 | 
             
                 */
         | 
| 2182 2182 | 
             
                mtu?: MTU;
         | 
| 2183 2183 | 
             
                /**
         | 
    
        package/clients/efs.d.ts
    CHANGED
    
    | @@ -1002,7 +1002,7 @@ declare namespace EFS { | |
| 1002 1002 | 
             
                Destinations: Destinations;
         | 
| 1003 1003 | 
             
              }
         | 
| 1004 1004 | 
             
              export type ReplicationConfigurationDescriptions = ReplicationConfigurationDescription[];
         | 
| 1005 | 
            -
              export type ReplicationStatus = "ENABLED"|"ENABLING"|"DELETING"|"ERROR"|string;
         | 
| 1005 | 
            +
              export type ReplicationStatus = "ENABLED"|"ENABLING"|"DELETING"|"ERROR"|"PAUSED"|"PAUSING"|string;
         | 
| 1006 1006 | 
             
              export type Resource = "FILE_SYSTEM"|"MOUNT_TARGET"|string;
         | 
| 1007 1007 | 
             
              export type ResourceId = string;
         | 
| 1008 1008 | 
             
              export interface ResourceIdPreference {
         | 
    
        package/clients/grafana.d.ts
    CHANGED
    
    | @@ -289,6 +289,10 @@ declare namespace Grafana { | |
| 289 289 | 
             
                 * The configuration string for the workspace that you create. For more information about the format and configuration options available, see Working in your Grafana workspace.
         | 
| 290 290 | 
             
                 */
         | 
| 291 291 | 
             
                configuration?: OverridableConfigurationJson;
         | 
| 292 | 
            +
                /**
         | 
| 293 | 
            +
                 * Specifies the version of Grafana to support in the new workspace. Supported values are 8.4 and 9.4.
         | 
| 294 | 
            +
                 */
         | 
| 295 | 
            +
                grafanaVersion?: GrafanaVersion;
         | 
| 292 296 | 
             
                /**
         | 
| 293 297 | 
             
                 * Configuration for network access to your workspace. When this is configured, only listed IP addresses and VPC endpoints will be able to access your workspace. Standard Grafana authentication and authorization will still be required. If this is not configured, or is removed, then all IP addresses and VPC endpoints will be allowed. Standard Grafana authentication and authorization will still be required.
         | 
| 294 298 | 
             
                 */
         | 
    
        package/clients/iot.d.ts
    CHANGED
    
    | @@ -3454,6 +3454,10 @@ declare namespace Iot { | |
| 3454 3454 | 
             
                 * Metadata which can be used to manage the domain configuration.  For URI Request parameters use format: ...key1=value1&key2=value2... For the CLI command-line parameter use format: &&tags "key1=value1&key2=value2..." For the cli-input-json file use format: "tags": "key1=value1&key2=value2..." 
         | 
| 3455 3455 | 
             
                 */
         | 
| 3456 3456 | 
             
                tags?: TagList;
         | 
| 3457 | 
            +
                /**
         | 
| 3458 | 
            +
                 * An object that specifies the TLS configuration for a domain.
         | 
| 3459 | 
            +
                 */
         | 
| 3460 | 
            +
                tlsConfig?: TlsConfig;
         | 
| 3457 3461 | 
             
              }
         | 
| 3458 3462 | 
             
              export interface CreateDomainConfigurationResponse {
         | 
| 3459 3463 | 
             
                /**
         | 
| @@ -3579,7 +3583,7 @@ declare namespace Iot { | |
| 3579 3583 | 
             
                 */
         | 
| 3580 3584 | 
             
                targets: JobTargets;
         | 
| 3581 3585 | 
             
                /**
         | 
| 3582 | 
            -
                 * An S3 link to the job document.  | 
| 3586 | 
            +
                 * An S3 link, or S3 object URL, to the job document. The link is an Amazon S3 object URL and is required if you don't specify a value for document. For example, --document-source https://s3.region-code.amazonaws.com/example-firmware/device-firmware.1.0. For more information, see Methods for accessing a bucket.
         | 
| 3583 3587 | 
             
                 */
         | 
| 3584 3588 | 
             
                documentSource?: JobDocumentSource;
         | 
| 3585 3589 | 
             
                /**
         | 
| @@ -4918,6 +4922,10 @@ declare namespace Iot { | |
| 4918 4922 | 
             
                 * The date and time the domain configuration's status was last changed.
         | 
| 4919 4923 | 
             
                 */
         | 
| 4920 4924 | 
             
                lastStatusChangeDate?: DateType;
         | 
| 4925 | 
            +
                /**
         | 
| 4926 | 
            +
                 * An object that specifies the TLS configuration for a domain.
         | 
| 4927 | 
            +
                 */
         | 
| 4928 | 
            +
                tlsConfig?: TlsConfig;
         | 
| 4921 4929 | 
             
              }
         | 
| 4922 4930 | 
             
              export interface DescribeEndpointRequest {
         | 
| 4923 4931 | 
             
                /**
         | 
| @@ -9014,7 +9022,7 @@ declare namespace Iot { | |
| 9014 9022 | 
             
              export type Prefix = string;
         | 
| 9015 9023 | 
             
              export interface PresignedUrlConfig {
         | 
| 9016 9024 | 
             
                /**
         | 
| 9017 | 
            -
                 * The ARN of an IAM role that grants  | 
| 9025 | 
            +
                 * The ARN of an IAM role that grants permission to download files from the S3 bucket where the job data/updates are stored. The role must also grant permission for IoT to download the files.  For information about addressing the confused deputy problem, see cross-service confused deputy prevention in the Amazon Web Services IoT Core developer guide. 
         | 
| 9018 9026 | 
             
                 */
         | 
| 9019 9027 | 
             
                roleArn?: RoleArn;
         | 
| 9020 9028 | 
             
                /**
         | 
| @@ -9648,6 +9656,7 @@ declare namespace Iot { | |
| 9648 9656 | 
             
              export type Seconds = number;
         | 
| 9649 9657 | 
             
              export type SecurityGroupId = string;
         | 
| 9650 9658 | 
             
              export type SecurityGroupList = SecurityGroupId[];
         | 
| 9659 | 
            +
              export type SecurityPolicy = string;
         | 
| 9651 9660 | 
             
              export type SecurityProfileArn = string;
         | 
| 9652 9661 | 
             
              export type SecurityProfileDescription = string;
         | 
| 9653 9662 | 
             
              export interface SecurityProfileIdentifier {
         | 
| @@ -10557,6 +10566,12 @@ declare namespace Iot { | |
| 10557 10566 | 
             
              export type TimestreamTimestampUnit = string;
         | 
| 10558 10567 | 
             
              export type TimestreamTimestampValue = string;
         | 
| 10559 10568 | 
             
              export type TinyMaxResults = number;
         | 
| 10569 | 
            +
              export interface TlsConfig {
         | 
| 10570 | 
            +
                /**
         | 
| 10571 | 
            +
                 * The security policy for a domain configuration. For more information, see Security policies  in the Amazon Web Services IoT Core developer guide.
         | 
| 10572 | 
            +
                 */
         | 
| 10573 | 
            +
                securityPolicy?: SecurityPolicy;
         | 
| 10574 | 
            +
              }
         | 
| 10560 10575 | 
             
              export interface TlsContext {
         | 
| 10561 10576 | 
             
                /**
         | 
| 10562 10577 | 
             
                 * The value of the serverName key in a TLS authorization request.
         | 
| @@ -11007,6 +11022,10 @@ declare namespace Iot { | |
| 11007 11022 | 
             
                 * Removes the authorization configuration from a domain.
         | 
| 11008 11023 | 
             
                 */
         | 
| 11009 11024 | 
             
                removeAuthorizerConfig?: RemoveAuthorizerConfig;
         | 
| 11025 | 
            +
                /**
         | 
| 11026 | 
            +
                 * An object that specifies the TLS configuration for a domain.
         | 
| 11027 | 
            +
                 */
         | 
| 11028 | 
            +
                tlsConfig?: TlsConfig;
         | 
| 11010 11029 | 
             
              }
         | 
| 11011 11030 | 
             
              export interface UpdateDomainConfigurationResponse {
         | 
| 11012 11031 | 
             
                /**
         |