@maxim_mazurok/gapi.client.spanner-v1 0.0.20230918 → 0.0.20230921

package/index.d.ts

@@ -9,7 +9,7 @@
 // This file was generated by https://github.com/Maxim-Mazurok/google-api-typings-generator. Please do not edit it manually.
 // In case of any problems please post issue to https://github.com/Maxim-Mazurok/google-api-typings-generator
 // Generated from: https://spanner.googleapis.com/$discovery/rest?version=v1
-// Revision: 20230918
+// Revision: 20230921
 
 /// <reference types="gapi.client" />
 
@@ -117,6 +117,25 @@ declare namespace gapi.client {
             session?:
                 Session[];
         }
+        interface BatchWriteRequest {
+            /** Required. The groups of mutations to be applied. */
+            mutationGroups?:
+                MutationGroup[];
+            /** Common options for this request. */
+            requestOptions?:
+                RequestOptions;
+        }
+        interface BatchWriteResponse {
+            /** The commit timestamp of the transaction that applied this batch. Present if `status` is `OK`, absent otherwise. */
+            commitTimestamp?:
+                string;
+            /** The mutation groups applied in this batch. The values index into the `mutation_groups` field in the corresponding `BatchWriteRequest`. */
+            indexes?:
+                number[];
+            /** An `OK` status indicates success. Any other status indicates a failure. */
+            status?:
+                Status;
+        }
         interface BeginTransactionRequest {
             /** Required. Options for the new transaction. */
             options?:
@@ -1092,6 +1111,11 @@ declare namespace gapi.client {
             update?:
                 Write;
         }
+        interface MutationGroup {
+            /** Required. The mutations in this group. */
+            mutations?:
+                Mutation[];
+        }
         interface Operation {
             /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
             done?:
@@ -1219,10 +1243,10 @@ declare namespace gapi.client {
             partitionOptions?:
                 PartitionOptions;
             /**
-             * Required. The query request to generate partitions for. The request will fail if the query is not root partitionable. The query plan of a root partitionable query has a single
-             * distributed union operator. A distributed union operator conceptually divides one or more tables into multiple splits, remotely evaluates a subquery independently on each split, and
-             * then unions all results. This must not contain DML commands, such as INSERT, UPDATE, or DELETE. Use ExecuteStreamingSql with a PartitionedDml transaction for large,
-             * partition-friendly DML operations.
+             * Required. The query request to generate partitions for. The request will fail if the query is not root partitionable. For a query to be root partitionable, it needs to satisfy a few
+             * conditions. For example, the first operator in the query execution plan must be a distributed union operator. For more information about other conditions, see [Read data in
+             * parallel](https://cloud.google.com/spanner/docs/reads#read_data_in_parallel). The query request must not contain DML commands, such as INSERT, UPDATE, or DELETE. Use
+             * ExecuteStreamingSql with a PartitionedDml transaction for large, partition-friendly DML operations.
              */
             sql?:
                 string;
@@ -3775,6 +3799,94 @@ declare namespace gapi.client {
                     string;
             },
             body: BatchCreateSessionsRequest): Request<BatchCreateSessionsResponse>;
+            /**
+             * Batches the supplied mutation groups in a collection of efficient transactions. All mutations in a group are committed atomically. However, mutations across groups can be committed
+             * non-atomically in an unspecified order and thus, they must be independent of each other. Partial failure is possible, i.e., some groups may have been committed successfully, while
+             * some may have failed. The results of individual batches are streamed into the response as the batches are applied. BatchWrite requests are not replay protected, meaning that each
+             * mutation group may be applied more than once. Replays of non-idempotent mutations may have undesirable effects. For example, replays of an insert mutation may produce an already
+             * exists error or if you use generated or commit timestamp-based keys, it may result in additional rows being added to the mutation's table. We recommend structuring your mutation
+             * groups to be idempotent to avoid this issue.
+             */
+            batchWrite(request: {
+                /** V1 error format. */
+                "$.xgafv"?:
+                    string;
+                /** OAuth access token. */
+                access_token?:
+                    string;
+                /** Data format for response. */
+                alt?:
+                    string;
+                /** JSONP */
+                callback?:
+                    string;
+                /** Selector specifying which fields to include in a partial response. */
+                fields?:
+                    string;
+                /** API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. */
+                key?:
+                    string;
+                /** OAuth 2.0 token for the current user. */
+                oauth_token?:
+                    string;
+                /** Returns response with indentations and line breaks. */
+                prettyPrint?:
+                    boolean;
+                /** Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters. */
+                quotaUser?:
+                    string;
+                /** Required. The session in which the batch request is to be run. */
+                session:
+                    string;
+                /** Upload protocol for media (e.g. "raw", "multipart"). */
+                upload_protocol?:
+                    string;
+                /** Legacy upload protocol for media (e.g. "media", "multipart"). */
+                uploadType?:
+                    string;
+                /** Request body */
+                resource:
+                    BatchWriteRequest;
+            }): Request<BatchWriteResponse>;
+            batchWrite(request: {
+                /** V1 error format. */
+                "$.xgafv"?:
+                    string;
+                /** OAuth access token. */
+                access_token?:
+                    string;
+                /** Data format for response. */
+                alt?:
+                    string;
+                /** JSONP */
+                callback?:
+                    string;
+                /** Selector specifying which fields to include in a partial response. */
+                fields?:
+                    string;
+                /** API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token. */
+                key?:
+                    string;
+                /** OAuth 2.0 token for the current user. */
+                oauth_token?:
+                    string;
+                /** Returns response with indentations and line breaks. */
+                prettyPrint?:
+                    boolean;
+                /** Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters. */
+                quotaUser?:
+                    string;
+                /** Required. The session in which the batch request is to be run. */
+                session:
+                    string;
+                /** Upload protocol for media (e.g. "raw", "multipart"). */
+                upload_protocol?:
+                    string;
+                /** Legacy upload protocol for media (e.g. "media", "multipart"). */
+                uploadType?:
+                    string;
+            },
+            body: BatchWriteRequest): Request<BatchWriteResponse>;
             /** Begins a new transaction. This step can often be skipped: Read, ExecuteSql and Commit can begin a new transaction as a side-effect. */
             beginTransaction(request: {
                 /** V1 error format. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxim_mazurok/gapi.client.spanner-v1",
-  "version": "0.0.20230918",
+  "version": "0.0.20230921",
   "description": "TypeScript typings for Cloud Spanner API v1",
   "license": "MIT",
   "author": {

package/tests.ts

@@ -3,7 +3,7 @@
 // This file was generated by https://github.com/Maxim-Mazurok/google-api-typings-generator. Please do not edit it manually.
 // In case of any problems please post issue to https://github.com/Maxim-Mazurok/google-api-typings-generator
 
-// Revision: 20230918
+// Revision: 20230921
 
 gapi.load('client', async () => {
     /** now we can use gapi.client */
@@ -756,6 +756,102 @@ gapi.load('client', async () => {
                 name: "Test string",
             },
         });
+        /**
+         * Batches the supplied mutation groups in a collection of efficient transactions. All mutations in a group are committed atomically. However, mutations across groups can be committed
+         * non-atomically in an unspecified order and thus, they must be independent of each other. Partial failure is possible, i.e., some groups may have been committed successfully, while some
+         * may have failed. The results of individual batches are streamed into the response as the batches are applied. BatchWrite requests are not replay protected, meaning that each mutation
+         * group may be applied more than once. Replays of non-idempotent mutations may have undesirable effects. For example, replays of an insert mutation may produce an already exists error or
+         * if you use generated or commit timestamp-based keys, it may result in additional rows being added to the mutation's table. We recommend structuring your mutation groups to be idempotent
+         * to avoid this issue.
+         */
+        await gapi.client.spanner.projects.instances.databases.sessions.batchWrite({
+            session: "Test string",
+        }, {
+            mutationGroups: [
+                {
+                    mutations: [
+                        {
+                            delete: {
+                                keySet: {
+                                    all: true,
+                                    keys: [
+                                        [
+                                            42
+                                        ]
+                                    ],
+                                    ranges: [
+                                        {
+                                            endClosed: [
+                                                42
+                                            ],
+                                            endOpen: [
+                                                42
+                                            ],
+                                            startClosed: [
+                                                42
+                                            ],
+                                            startOpen: [
+                                                42
+                                            ],
+                                        }
+                                    ],
+                                },
+                                table: "Test string",
+                            },
+                            insert: {
+                                columns: [
+                                    "Test string"
+                                ],
+                                table: "Test string",
+                                values: [
+                                    [
+                                        42
+                                    ]
+                                ],
+                            },
+                            insertOrUpdate: {
+                                columns: [
+                                    "Test string"
+                                ],
+                                table: "Test string",
+                                values: [
+                                    [
+                                        42
+                                    ]
+                                ],
+                            },
+                            replace: {
+                                columns: [
+                                    "Test string"
+                                ],
+                                table: "Test string",
+                                values: [
+                                    [
+                                        42
+                                    ]
+                                ],
+                            },
+                            update: {
+                                columns: [
+                                    "Test string"
+                                ],
+                                table: "Test string",
+                                values: [
+                                    [
+                                        42
+                                    ]
+                                ],
+                            },
+                        }
+                    ],
+                }
+            ],
+            requestOptions: {
+                priority: "Test string",
+                requestTag: "Test string",
+                transactionTag: "Test string",
+            },
+        });
         /** Begins a new transaction. This step can often be skipped: Read, ExecuteSql and Commit can begin a new transaction as a side-effect. */
         await gapi.client.spanner.projects.instances.databases.sessions.beginTransaction({
             session: "Test string",