@milaboratories/pl-client 2.16.8 → 2.16.10

package/src/core/ll_client.ts

@@ -1,4 +1,4 @@
-import { PlatformClient } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api.client';
+import { PlatformClient as GrpcPlApiClient } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.client';
 import type { ClientOptions, Interceptor } from '@grpc/grpc-js';
 import {
   ChannelCredentials,
@@ -13,26 +13,31 @@ import type {
   PlConnectionStatus,
   PlConnectionStatusListener,
 } from './config';
-import { plAddressToConfig } from './config';
+import { plAddressToConfig, type wireProtocol, SUPPORTED_WIRE_PROTOCOLS } from './config';
 import type { GrpcOptions } from '@protobuf-ts/grpc-transport';
 import { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import { LLPlTransaction } from './ll_transaction';
 import { parsePlJwt } from '../util/pl';
-import type { Dispatcher } from 'undici';
+import { type Dispatcher, interceptors } from 'undici';
+import type { Middleware } from 'openapi-fetch';
 import { inferAuthRefreshTime } from './auth';
 import { defaultHttpDispatcher } from '@milaboratories/pl-http';
-import type { GrpcClientProvider, GrpcClientProviderFactory } from './grpc';
+import type { WireClientProvider, WireClientProviderFactory, WireConnection } from './wire';
 import { parseHttpAuth } from '@milaboratories/pl-model-common';
+import type * as grpcTypes from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
+import { type PlApiPaths, type PlRestClientType, createClient, parseResponseError } from '../proto-rest';
+import { notEmpty } from '@milaboratories/ts-helpers';
+import { Code } from '../proto-grpc/google/rpc/code';
 
 export interface PlCallOps {
   timeout?: number;
   abortSignal?: AbortSignal;
 }
 
-class GrpcClientProviderImpl<Client> implements GrpcClientProvider<Client> {
+class WireClientProviderImpl<Client> implements WireClientProvider<Client> {
   private client: Client | undefined = undefined;
 
-  constructor(private readonly grpcTransport: () => GrpcTransport, private readonly clientConstructor: (transport: GrpcTransport) => Client) {}
+  constructor(private readonly wireOpts: () => WireConnection, private readonly clientConstructor: (wireOpts: WireConnection) => Client) {}
 
   public reset(): void {
     this.client = undefined;
@@ -40,13 +45,13 @@ class GrpcClientProviderImpl<Client> implements GrpcClientProvider<Client> {
 
   public get(): Client {
     if (this.client === undefined)
-      this.client = this.clientConstructor(this.grpcTransport());
+      this.client = this.clientConstructor(this.wireOpts());
     return this.client;
   }
 }
 
 /** Abstract out low level networking and authorization details */
-export class LLPlClient implements GrpcClientProviderFactory {
+export class LLPlClient implements WireClientProviderFactory {
   public readonly conf: PlClientConfig;
 
   /** Initial authorization information */
@@ -63,11 +68,15 @@ export class LLPlClient implements GrpcClientProviderFactory {
   private _status: PlConnectionStatus = 'OK';
   private readonly statusListener?: PlConnectionStatusListener;
 
-  private readonly grpcInterceptors: Interceptor[];
-  private _grpcTransport!: GrpcTransport;
-  private readonly providers: WeakRef<GrpcClientProviderImpl<any>>[] = [];
+  private _wireProto: wireProtocol | undefined = undefined;
+  private _wireConn!: WireConnection;
 
-  public readonly grpcPl: GrpcClientProvider<PlatformClient>;
+  private readonly _restInterceptors: Dispatcher.DispatcherComposeInterceptor[];
+  private readonly _restMiddlewares: Middleware[];
+  private readonly _grpcInterceptors: Interceptor[];
+  private readonly providers: WeakRef<WireClientProviderImpl<any>>[] = [];
+
+  public readonly clientProvider: WireClientProvider<PlRestClientType | GrpcPlApiClient>;
 
   public readonly httpDispatcher: Dispatcher;
 
@@ -83,45 +92,87 @@ export class LLPlClient implements GrpcClientProviderFactory {
       ? plAddressToConfig(configOrAddress)
       : configOrAddress;
 
-    this.grpcInterceptors = [];
-
-    const { auth, statusListener, shouldUseGzip } = ops;
+    const { auth, statusListener } = ops;
 
     if (auth !== undefined) {
       this.refreshTimestamp = inferAuthRefreshTime(
         auth.authInformation,
         this.conf.authMaxRefreshSeconds,
       );
-      this.grpcInterceptors.push(this.createAuthInterceptor());
       this.authInformation = auth.authInformation;
       this.onAuthUpdate = auth.onUpdate;
       this.onAuthRefreshProblem = auth.onUpdateError;
       this.onAuthError = auth.onAuthError;
     }
 
-    this.grpcInterceptors.push(this.createErrorInterceptor());
+    this._restInterceptors = [];
+    this._restMiddlewares = [];
+    this._grpcInterceptors = [];
 
-    // initialize _grpcTransport and _grpcPl
-    this.initGrpc(shouldUseGzip ?? false);
+    if (auth !== undefined) {
+      this._restInterceptors.push(this.createRestAuthInterceptor());
+      this._grpcInterceptors.push(this.createGrpcAuthInterceptor());
+    }
+    this._restInterceptors.push(interceptors.retry({ statusCodes: [] })); // Handle errors with openapi-fetch middleware.
+    this._restMiddlewares.push(this.createRestErrorMiddleware());
+    this._grpcInterceptors.push(this.createGrpcErrorInterceptor());
 
     this.httpDispatcher = defaultHttpDispatcher(this.conf.httpProxy);
 
+    this.initWireConnection();
+
     if (statusListener !== undefined) {
       this.statusListener = statusListener;
       statusListener(this._status);
     }
 
-    this.grpcPl = this.createGrpcClientProvider((transport) => new PlatformClient(transport));
+    this.clientProvider = this.createWireClientProvider((wireConn) => {
+      if (wireConn.type === 'grpc') {
+        return new GrpcPlApiClient(wireConn.Transport);
+      } else {
+        return createClient<PlApiPaths>({
+          hostAndPort: wireConn.Config.hostAndPort,
+          ssl: wireConn.Config.ssl,
+          dispatcher: wireConn.Dispatcher,
+          middlewares: wireConn.Middlewares,
+        });
+      }
+    });
+  }
+
+  private initWireConnection() {
+    if (this._wireProto === undefined) {
+      // TODO: implement automatic server mode detection
+      this._wireProto = this.conf.wireProtocol ?? 'grpc';
+    }
+
+    switch (this._wireProto) {
+      case 'rest':
+        this.initRestConnection();
+        return;
+      case 'grpc':
+        this.initGrpcConnection(this.ops.shouldUseGzip ?? false);
+        return;
+      default:
+        ((v: never) => {
+          throw new Error(`Unsupported wire protocol '${v as string}'. Use one of: ${SUPPORTED_WIRE_PROTOCOLS.join(', ')}`);
+        })(this._wireProto);
+    }
+  }
+
+  private initRestConnection(): void {
+    const dispatcher = defaultHttpDispatcher(this.conf.httpProxy, this._restInterceptors);
+    this._replaceWireConnection({ type: 'rest', Config: this.conf, Dispatcher: dispatcher, Middlewares: this._restMiddlewares });
   }
 
   /**
-   * Initializes (or reinitializes) _grpcTransport and _grpcPl
+   * Initializes (or reinitializes) _grpcTransport
    * @param gzip - whether to enable gzip compression
    */
-  private initGrpc(gzip: boolean) {
+  private initGrpcConnection(gzip: boolean) {
     const clientOptions: ClientOptions = {
       'grpc.keepalive_time_ms': 30_000, // 30 seconds
-      'interceptors': this.grpcInterceptors,
+      'interceptors': this._grpcInterceptors,
     };
 
     if (gzip) clientOptions['grpc.default_compression_algorithm'] = compressionAlgorithms.gzip;
@@ -161,9 +212,12 @@ export class LLPlClient implements GrpcClientProviderFactory {
       delete process.env.grpc_proxy;
     }
 
-    const oldTransport = this._grpcTransport;
+    this._replaceWireConnection({ type: 'grpc', Transport: new GrpcTransport(grpcOptions) });
+  }
 
-    this._grpcTransport = new GrpcTransport(grpcOptions);
+  private _replaceWireConnection(newConn: WireConnection): void {
+    const oldConn = this._wireConn;
+    this._wireConn = newConn;
 
     // Reset all providers to let them reinitialize their clients
     for (let i = 0; i < this.providers.length; i++) {
@@ -177,7 +231,7 @@ export class LLPlClient implements GrpcClientProviderFactory {
       }
     }
 
-    if (oldTransport !== undefined) oldTransport.close();
+    if (oldConn !== undefined && oldConn.type === 'grpc') oldConn.Transport.close();
   }
 
   private providerCleanupCounter = 0;
@@ -187,7 +241,7 @@ export class LLPlClient implements GrpcClientProviderFactory {
    *
    * @param clientConstructor - a factory function that creates a grpc client
    */
-  public createGrpcClientProvider<Client>(clientConstructor: (transport: GrpcTransport) => Client): GrpcClientProvider<Client> {
+  public createWireClientProvider<Client>(clientConstructor: (transport: WireConnection) => Client): WireClientProvider<Client> {
     // We need to cleanup providers periodically to avoid memory leaks.
     // This is a simple heuristic to avoid memory leaks.
     // We could use a more sophisticated algorithm, but this is good enough for now.
@@ -203,13 +257,13 @@ export class LLPlClient implements GrpcClientProviderFactory {
       this.providerCleanupCounter = 0;
     }
 
-    const provider = new GrpcClientProviderImpl<Client>(() => this._grpcTransport, clientConstructor);
+    const provider = new WireClientProviderImpl<Client>(() => this._wireConn, clientConstructor);
     this.providers.push(new WeakRef(provider));
     return provider;
   }
 
-  public get grpcTransport(): GrpcTransport {
-    return this._grpcTransport;
+  public get wireConnection(): WireConnection {
+    return this._wireConn;
   }
 
   /** Returns true if client is authenticated. Even with anonymous auth information
@@ -256,13 +310,8 @@ export class LLPlClient implements GrpcClientProviderFactory {
     this.authRefreshInProgress = true;
     void (async () => {
       try {
-        const response = await this.grpcPl.get().getJWTToken({
-          expiration: {
-            seconds: BigInt(this.conf.authTTLSeconds),
-            nanos: 0,
-          },
-        }).response;
-        this.authInformation = { jwtToken: response.token };
+        const token = await this.getJwtToken(BigInt(this.conf.authTTLSeconds));
+        this.authInformation = { jwtToken: token };
         this.refreshTimestamp = inferAuthRefreshTime(
           this.authInformation,
           this.conf.authMaxRefreshSeconds,
@@ -276,8 +325,45 @@ export class LLPlClient implements GrpcClientProviderFactory {
     })();
   }
 
-  /** Detects certain errors and update client status accordingly */
-  private createErrorInterceptor(): Interceptor {
+  /**
+   * Creates middleware that parses error responses and handles them centrally.
+   * This middleware runs before openapi-fetch parses the response, so we need to
+   * manually parse the response body for error responses.
+   */
+  private createRestErrorMiddleware(): Middleware {
+    return {
+      onResponse: async ({ request: _request, response, options: _options }) => {
+        const { body: body, ...resOptions } = response;
+
+        if ([502, 503, 504].includes(response.status)) {
+          // Service unavailable, bad gateway, gateway timeout
+          this.updateStatus('Disconnected');
+          return new Response(body, { ...resOptions, status: response.status });
+        }
+
+        const respErr = await parseResponseError(response);
+        if (!respErr.error) {
+          // No error: nice!
+          return new Response(respErr.origBody ?? body, { ...resOptions, status: response.status });
+        }
+
+        if (typeof respErr.error === 'string') {
+          // Non-standard error or normal response: let later middleware to deal wit it.
+          return new Response(respErr.error, { ...resOptions, status: response.status });
+        }
+
+        if (respErr.error.code === Code.UNAUTHENTICATED) {
+          this.updateStatus('Unauthenticated');
+        }
+
+        // Let later middleware to deal with standard gRPC error.
+        return new Response(respErr.origBody, { ...resOptions, status: response.status });
+      },
+    };
+  }
+
+  /** Detects certain errors and update client status accordingly when using GRPC wire connection */
+  private createGrpcErrorInterceptor(): Interceptor {
     return (options, nextCall) => {
       return new InterceptingCall(nextCall(options), {
         start: (metadata, listener, next) => {
@@ -297,8 +383,22 @@ export class LLPlClient implements GrpcClientProviderFactory {
     };
   }
 
+  private createRestAuthInterceptor(): Dispatcher.DispatcherComposeInterceptor {
+    return (dispatch) => {
+      return (options, handler) => {
+        if (this.authInformation?.jwtToken !== undefined) {
+          // TODO: check this magic really works and gets called
+          options.headers = { ...options.headers, authorization: 'Bearer ' + this.authInformation.jwtToken };
+          this.refreshAuthInformationIfNeeded();
+        }
+
+        return dispatch(options, handler);
+      };
+    };
+  }
+
   /** Injects authentication information if needed */
-  private createAuthInterceptor(): Interceptor {
+  private createGrpcAuthInterceptor(): Interceptor {
     return (options, nextCall) => {
       return new InterceptingCall(nextCall(options), {
         start: (metadata, listener, next) => {
@@ -314,11 +414,77 @@ export class LLPlClient implements GrpcClientProviderFactory {
     };
   }
 
+  public async getJwtToken(ttlSeconds: bigint, options?: { authorization?: string }): Promise<string> {
+    const cl = this.clientProvider.get();
+
+    if (cl instanceof GrpcPlApiClient) {
+      const meta: Record<string, string> = {};
+      if (options?.authorization) meta.authorization = options.authorization;
+      return (await cl.getJWTToken({ expiration: { seconds: ttlSeconds, nanos: 0 } }, { meta }).response).token;
+    } else {
+      const headers: Record<string, string> = {};
+      if (options?.authorization) headers.authorization = options.authorization;
+      const resp = cl.POST('/v1/auth/jwt-token', {
+        body: { expiration: `${ttlSeconds}s` },
+        headers,
+      });
+      return notEmpty((await resp).data).token;
+    }
+  }
+
+  public async ping(): Promise<grpcTypes.MaintenanceAPI_Ping_Response> {
+    const cl = this.clientProvider.get();
+    if (cl instanceof GrpcPlApiClient) {
+      return (await cl.ping({})).response;
+    } else {
+      return notEmpty((await cl.GET('/v1/ping')).data);
+    }
+  }
+
+  public async license(): Promise<grpcTypes.MaintenanceAPI_License_Response> {
+    const cl = this.clientProvider.get();
+    if (cl instanceof GrpcPlApiClient) {
+      return (await cl.license({})).response;
+    } else {
+      const resp = notEmpty((await cl.GET('/v1/license')).data);
+      return {
+        status: resp.status,
+        isOk: resp.isOk,
+        responseBody: Uint8Array.from(Buffer.from(resp.responseBody)),
+      };
+    }
+  }
+
+  public async authMethods(): Promise<grpcTypes.AuthAPI_ListMethods_Response> {
+    const cl = this.clientProvider.get();
+    if (cl instanceof GrpcPlApiClient) {
+      return (await cl.authMethods({})).response;
+    } else {
+      return notEmpty((await cl.GET('/v1/auth/methods')).data);
+    }
+  }
+
+  public async txSync(txId: bigint): Promise<void> {
+    const cl = this.clientProvider.get();
+    if (cl instanceof GrpcPlApiClient) {
+      await cl.txSync({ txId: BigInt(txId) });
+    } else {
+      (await cl.POST('/v1/tx-sync', { body: { txId: txId.toString() } }));
+    }
+  }
+
   createTx(rw: boolean, ops: PlCallOps = {}): LLPlTransaction {
     return new LLPlTransaction((abortSignal) => {
       let totalAbortSignal = abortSignal;
       if (ops.abortSignal) totalAbortSignal = AbortSignal.any([totalAbortSignal, ops.abortSignal]);
-      return this.grpcPl.get().tx({
+
+      const cl = this.clientProvider.get();
+      if (!(cl instanceof GrpcPlApiClient)) {
+        // TODO: add WebSockets
+        throw new Error('tx is not supported for REST client');
+      }
+
+      return cl.tx({
         abort: totalAbortSignal,
         timeout: ops.timeout
           ?? (rw ? this.conf.defaultRWTransactionTimeout : this.conf.defaultROTransactionTimeout),
@@ -328,7 +494,11 @@ export class LLPlClient implements GrpcClientProviderFactory {
 
   /** Closes underlying transport */
   public async close() {
-    this.grpcTransport.close();
+    if (this.wireConnection.type === 'grpc') {
+      this.wireConnection.Transport.close();
+    } else {
+      // TODO: close all WS connections
+    }
     await this.httpDispatcher.destroy();
   }
 }

package/src/core/ll_transaction.test.ts

@@ -1,5 +1,5 @@
 import { getTestLLClient } from '../test/test_config';
-import { TxAPI_Open_Request_WritableTx } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api';
+import { TxAPI_Open_Request_WritableTx } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
 import { createLocalResourceId } from './types';
 import { test, expect } from 'vitest';
 

package/src/core/ll_transaction.ts

@@ -1,10 +1,10 @@
 import type {
   TxAPI_ClientMessage,
   TxAPI_ServerMessage,
-} from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api';
-import type { DuplexStreamingCall } from '@protobuf-ts/runtime-rpc';
+} from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
+import type { BiDiStream } from './abstract_stream';
 import Denque from 'denque';
-import type { Status } from '../proto/github.com/googleapis/googleapis/google/rpc/status';
+import type { Status } from '../proto-grpc/github.com/googleapis/googleapis/google/rpc/status';
 import {
   PlErrorCodeNotFound,
   RecoverablePlError,
@@ -17,7 +17,7 @@ export type ClientMessageRequest = TxAPI_ClientMessage['request'];
 
 export type ServerMessageResponse = TxAPI_ServerMessage['response'];
 
-type TxStream = DuplexStreamingCall<TxAPI_ClientMessage, TxAPI_ServerMessage>;
+type TxStream = BiDiStream<TxAPI_ClientMessage, TxAPI_ServerMessage>;
 
 export type OneOfKind<T extends { oneofKind: unknown }, Kind extends T['oneofKind']> = Extract<
   T,

package/src/core/transaction.ts

@@ -25,7 +25,7 @@ import type {
   OneOfKind,
   ServerMessageResponse,
 } from './ll_transaction';
-import { TxAPI_Open_Request_WritableTx } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api';
+import { TxAPI_Open_Request_WritableTx } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
 import type { NonUndefined } from 'utility-types';
 import { toBytes } from '../util/util';
 import { fieldTypeToProto, protoToField, protoToResource } from './type_conversion';

package/src/core/type_conversion.ts

@@ -1,11 +1,11 @@
 import type {
   Field,
-  Resource } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api_types';
+  Resource } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api_types';
 import {
   Field_ValueStatus,
   Resource_Kind,
-} from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api_types';
-import { FieldType as GrpcFieldType } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/base_types';
+} from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api_types';
+import { FieldType as GrpcFieldType } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/base_types';
 import type {
   FieldData,
   FieldStatus,

package/src/core/unauth_client.test.ts

@@ -9,6 +9,12 @@ test('ping test', async () => {
   expect(response).toHaveProperty('coreVersion');
 });
 
+test('get auth methods', async () => {
+  const client = new UnauthenticatedPlClient(getTestConfig().address);
+  const response = await client.authMethods();
+  expect(response).toHaveProperty('methods');
+});
+
 test('wrong login', async () => {
   const testConfig = getTestConfig();
   if (testConfig.test_user === undefined || testConfig.test_password === undefined) {

package/src/core/unauth_client.ts

@@ -2,7 +2,7 @@ import type { AuthInformation, PlClientConfig } from './config';
 import type {
   AuthAPI_ListMethods_Response,
   MaintenanceAPI_Ping_Response,
-} from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api';
+} from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
 import { LLPlClient } from './ll_client';
 import { notEmpty } from '@milaboratories/ts-helpers';
 import { UnauthenticatedError } from './errors';
@@ -16,11 +16,11 @@ export class UnauthenticatedPlClient {
   }
 
   public async ping(): Promise<MaintenanceAPI_Ping_Response> {
-    return (await this.ll.grpcPl.get().ping({})).response;
+    return await this.ll.ping();
   }
 
   public async authMethods(): Promise<AuthAPI_ListMethods_Response> {
-    return (await this.ll.grpcPl.get().authMethods({})).response;
+    return await this.ll.authMethods();
   }
 
   public async requireAuth(): Promise<boolean> {
@@ -29,15 +29,11 @@ export class UnauthenticatedPlClient {
 
   public async login(user: string, password: string): Promise<AuthInformation> {
     try {
-      const response = await this.ll.grpcPl.get().getJWTToken(
-        { expiration: { seconds: BigInt(this.ll.conf.authTTLSeconds), nanos: 0 } },
-        {
-          meta: {
-            authorization: 'Basic ' + Buffer.from(user + ':' + password).toString('base64'),
-          },
-        },
-      ).response;
-      const jwtToken = notEmpty(response.token);
+      const token = await this.ll.getJwtToken(
+        BigInt(this.ll.conf.authTTLSeconds),
+        { authorization: 'Basic ' + Buffer.from(user + ':' + password).toString('base64') },
+      );
+      const jwtToken = notEmpty(token);
       if (jwtToken === '') throw new Error('empty token');
       return { jwtToken };
     } catch (e: any) {

package/src/core/wire.ts

@@ -0,0 +1,40 @@
+import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
+import type { Dispatcher } from 'undici';
+import type { PlClientConfig, wireProtocol } from './config';
+import type { Middleware } from 'openapi-fetch';
+
+/**
+ * Options for the HTTP client to properly reach the PL server API when
+ * it works in WebSocket + REST mode.
+ */
+export type RestConnection = {
+  type: 'rest';
+  Config: PlClientConfig;
+  Dispatcher: Dispatcher;
+  Middlewares: Middleware[];
+};
+
+export type GrpcConnection = {
+  type: 'grpc';
+  Transport: GrpcTransport;
+};
+
+export type WireConnection = RestConnection | GrpcConnection;
+// type compatibility check: types used in WireConnection should match known wire protocols.
+const _ct: Extract<WireConnection, { type: string }>['type'] = 'rest' as wireProtocol;
+
+/**
+ * A provider for a wire (gRPC, HTTP, etc.) client.
+ * The client is created on demand, and is reset when the transport is reset.
+ * This is useful for cases where the client is used in a loop, and the transport is reset after each iteration.
+ */
+export interface WireClientProvider<Client> {
+  get(): Client;
+}
+
+/**
+ * A factory for wire client providers.
+ */
+export interface WireClientProviderFactory {
+  createWireClientProvider<Client>(clientConstructor: (transport: WireConnection) => Client): WireClientProvider<Client>;
+}

package/src/index.ts

@@ -9,8 +9,10 @@ export * from './core/default_client';
 export * from './core/unauth_client';
 export * from './core/auth';
 export * from './core/final';
-export * from './core/grpc';
+export * from './core/wire';
 export * from './helpers/tx_helpers';
 export * from './helpers/poll';
 
 export * as TestHelpers from './test/test_config';
+
+export * as RestAPI from './proto-rest';

package/src/{proto → proto-grpc}/github.com/googleapis/googleapis/google/rpc/status.ts

@@ -2,7 +2,7 @@
 // @generated from protobuf file "github.com/googleapis/googleapis/google/rpc/status.proto" (package "google.rpc", syntax proto3)
 // tslint:disable
 //
-// Copyright 2020 Google LLC
+// Copyright 2025 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -39,7 +39,8 @@ import { Any } from "../../../../../google/protobuf/any";
  */
 export interface Status {
     /**
-     * The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
+     * The status code, which should be an enum value of
+     * [google.rpc.Code][google.rpc.Code].
      *
      * @generated from protobuf field: int32 code = 1
      */
@@ -47,7 +48,8 @@ export interface Status {
     /**
      * A developer-facing error message, which should be in English. Any
      * user-facing error message should be localized and sent in the
-     * [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
+     * [google.rpc.Status.details][google.rpc.Status.details] field, or localized
+     * by the client.
      *
      * @generated from protobuf field: string message = 2
      */