@nsshunt/stsappframework 3.1.31 → 3.1.32

package/src/gRPC/ststest/protos/grpc/testing/Request.ts

@@ -0,0 +1,12 @@
+// Original file: protos/auth_sample.proto
+
+
+export interface Request {
+  'fillUsername'?: (boolean);
+  'fillOauthScope'?: (boolean);
+}
+
+export interface Request__Output {
+  'fillUsername': (boolean);
+  'fillOauthScope': (boolean);
+}

package/src/gRPC/ststest/protos/grpc/testing/Response.ts

@@ -0,0 +1,12 @@
+// Original file: protos/auth_sample.proto
+
+
+export interface Response {
+  'username'?: (string);
+  'oauthScope'?: (string);
+}
+
+export interface Response__Output {
+  'username': (string);
+  'oauthScope': (string);
+}

package/src/gRPC/ststest/protos/grpc/testing/TestService.ts

@@ -0,0 +1,27 @@
+// Original file: protos/auth_sample.proto
+
+import type * as grpc from '@grpc/grpc-js'
+import type { MethodDefinition } from '@grpc/proto-loader'
+import type { Request as _grpc_testing_Request, Request__Output as _grpc_testing_Request__Output } from '../../grpc/testing/Request';
+import type { Response as _grpc_testing_Response, Response__Output as _grpc_testing_Response__Output } from '../../grpc/testing/Response';
+
+export interface TestServiceClient extends grpc.Client {
+  UnaryCall(argument: _grpc_testing_Request, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_grpc_testing_Response__Output>): grpc.ClientUnaryCall;
+  UnaryCall(argument: _grpc_testing_Request, metadata: grpc.Metadata, callback: grpc.requestCallback<_grpc_testing_Response__Output>): grpc.ClientUnaryCall;
+  UnaryCall(argument: _grpc_testing_Request, options: grpc.CallOptions, callback: grpc.requestCallback<_grpc_testing_Response__Output>): grpc.ClientUnaryCall;
+  UnaryCall(argument: _grpc_testing_Request, callback: grpc.requestCallback<_grpc_testing_Response__Output>): grpc.ClientUnaryCall;
+  unaryCall(argument: _grpc_testing_Request, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_grpc_testing_Response__Output>): grpc.ClientUnaryCall;
+  unaryCall(argument: _grpc_testing_Request, metadata: grpc.Metadata, callback: grpc.requestCallback<_grpc_testing_Response__Output>): grpc.ClientUnaryCall;
+  unaryCall(argument: _grpc_testing_Request, options: grpc.CallOptions, callback: grpc.requestCallback<_grpc_testing_Response__Output>): grpc.ClientUnaryCall;
+  unaryCall(argument: _grpc_testing_Request, callback: grpc.requestCallback<_grpc_testing_Response__Output>): grpc.ClientUnaryCall;
+  
+}
+
+export interface TestServiceHandlers extends grpc.UntypedServiceImplementation {
+  UnaryCall: grpc.handleUnaryCall<_grpc_testing_Request__Output, _grpc_testing_Response>;
+  
+}
+
+export interface TestServiceDefinition extends grpc.ServiceDefinition {
+  UnaryCall: MethodDefinition<_grpc_testing_Request, _grpc_testing_Response, _grpc_testing_Request__Output, _grpc_testing_Response__Output>
+}

package/src/gRPC/ststest/protos/hellostreamingworld/HelloReply.ts

@@ -0,0 +1,10 @@
+// Original file: protos/hellostreamingworld.proto
+
+
+export interface HelloReply {
+  'message'?: (string);
+}
+
+export interface HelloReply__Output {
+  'message': (string);
+}

package/src/gRPC/ststest/protos/hellostreamingworld/HelloRequest.ts

@@ -0,0 +1,12 @@
+// Original file: protos/hellostreamingworld.proto
+
+
+export interface HelloRequest {
+  'name'?: (string);
+  'numGreetings'?: (string);
+}
+
+export interface HelloRequest__Output {
+  'name': (string);
+  'numGreetings': (string);
+}

package/src/gRPC/ststest/protos/hellostreamingworld/MultiGreeter.ts

@@ -0,0 +1,23 @@
+// Original file: protos/hellostreamingworld.proto
+
+import type * as grpc from '@grpc/grpc-js'
+import type { MethodDefinition } from '@grpc/proto-loader'
+import type { HelloReply as _hellostreamingworld_HelloReply, HelloReply__Output as _hellostreamingworld_HelloReply__Output } from '../hellostreamingworld/HelloReply';
+import type { HelloRequest as _hellostreamingworld_HelloRequest, HelloRequest__Output as _hellostreamingworld_HelloRequest__Output } from '../hellostreamingworld/HelloRequest';
+
+export interface MultiGreeterClient extends grpc.Client {
+  sayHello(argument: _hellostreamingworld_HelloRequest, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_hellostreamingworld_HelloReply__Output>;
+  sayHello(argument: _hellostreamingworld_HelloRequest, options?: grpc.CallOptions): grpc.ClientReadableStream<_hellostreamingworld_HelloReply__Output>;
+  sayHello(argument: _hellostreamingworld_HelloRequest, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_hellostreamingworld_HelloReply__Output>;
+  sayHello(argument: _hellostreamingworld_HelloRequest, options?: grpc.CallOptions): grpc.ClientReadableStream<_hellostreamingworld_HelloReply__Output>;
+  
+}
+
+export interface MultiGreeterHandlers extends grpc.UntypedServiceImplementation {
+  sayHello: grpc.handleServerStreamingCall<_hellostreamingworld_HelloRequest__Output, _hellostreamingworld_HelloReply>;
+  
+}
+
+export interface MultiGreeterDefinition extends grpc.ServiceDefinition {
+  sayHello: MethodDefinition<_hellostreamingworld_HelloRequest, _hellostreamingworld_HelloReply, _hellostreamingworld_HelloRequest__Output, _hellostreamingworld_HelloReply__Output>
+}

package/src/gRPC/ststest/protos/hellostreamingworld.ts

@@ -0,0 +1,18 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import type * as grpc from '@grpc/grpc-js';
+import type { MessageTypeDefinition } from '@grpc/proto-loader';
+
+import type { MultiGreeterClient as _hellostreamingworld_MultiGreeterClient, MultiGreeterDefinition as _hellostreamingworld_MultiGreeterDefinition } from './hellostreamingworld/MultiGreeter';
+
+type SubtypeConstructor<Constructor extends new (...args: any) => any, Subtype> = {
+  new(...args: ConstructorParameters<Constructor>): Subtype;
+};
+
+export interface ProtoGrpcType {
+  hellostreamingworld: {
+    HelloReply: MessageTypeDefinition
+    HelloRequest: MessageTypeDefinition
+    MultiGreeter: SubtypeConstructor<typeof grpc.Client, _hellostreamingworld_MultiGreeterClient> & { service: _hellostreamingworld_MultiGreeterDefinition }
+  }
+}
+

package/src/gRPC/ststest/protos/helloworld/Greeter.ts

@@ -0,0 +1,35 @@
+// Original file: protos/helloworld.proto
+
+import type * as grpc from '@grpc/grpc-js'
+import type { MethodDefinition } from '@grpc/proto-loader'
+import type { HelloReply as _helloworld_HelloReply, HelloReply__Output as _helloworld_HelloReply__Output } from '../helloworld/HelloReply';
+import type { HelloRequest as _helloworld_HelloRequest, HelloRequest__Output as _helloworld_HelloRequest__Output } from '../helloworld/HelloRequest';
+
+export interface GreeterClient extends grpc.Client {
+  SayHello(argument: _helloworld_HelloRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_helloworld_HelloReply__Output>): grpc.ClientUnaryCall;
+  SayHello(argument: _helloworld_HelloRequest, metadata: grpc.Metadata, callback: grpc.requestCallback<_helloworld_HelloReply__Output>): grpc.ClientUnaryCall;
+  SayHello(argument: _helloworld_HelloRequest, options: grpc.CallOptions, callback: grpc.requestCallback<_helloworld_HelloReply__Output>): grpc.ClientUnaryCall;
+  SayHello(argument: _helloworld_HelloRequest, callback: grpc.requestCallback<_helloworld_HelloReply__Output>): grpc.ClientUnaryCall;
+  sayHello(argument: _helloworld_HelloRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_helloworld_HelloReply__Output>): grpc.ClientUnaryCall;
+  sayHello(argument: _helloworld_HelloRequest, metadata: grpc.Metadata, callback: grpc.requestCallback<_helloworld_HelloReply__Output>): grpc.ClientUnaryCall;
+  sayHello(argument: _helloworld_HelloRequest, options: grpc.CallOptions, callback: grpc.requestCallback<_helloworld_HelloReply__Output>): grpc.ClientUnaryCall;
+  sayHello(argument: _helloworld_HelloRequest, callback: grpc.requestCallback<_helloworld_HelloReply__Output>): grpc.ClientUnaryCall;
+  
+  SayHelloStreamReply(argument: _helloworld_HelloRequest, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_helloworld_HelloReply__Output>;
+  SayHelloStreamReply(argument: _helloworld_HelloRequest, options?: grpc.CallOptions): grpc.ClientReadableStream<_helloworld_HelloReply__Output>;
+  sayHelloStreamReply(argument: _helloworld_HelloRequest, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_helloworld_HelloReply__Output>;
+  sayHelloStreamReply(argument: _helloworld_HelloRequest, options?: grpc.CallOptions): grpc.ClientReadableStream<_helloworld_HelloReply__Output>;
+  
+}
+
+export interface GreeterHandlers extends grpc.UntypedServiceImplementation {
+  SayHello: grpc.handleUnaryCall<_helloworld_HelloRequest__Output, _helloworld_HelloReply>;
+  
+  SayHelloStreamReply: grpc.handleServerStreamingCall<_helloworld_HelloRequest__Output, _helloworld_HelloReply>;
+  
+}
+
+export interface GreeterDefinition extends grpc.ServiceDefinition {
+  SayHello: MethodDefinition<_helloworld_HelloRequest, _helloworld_HelloReply, _helloworld_HelloRequest__Output, _helloworld_HelloReply__Output>
+  SayHelloStreamReply: MethodDefinition<_helloworld_HelloRequest, _helloworld_HelloReply, _helloworld_HelloRequest__Output, _helloworld_HelloReply__Output>
+}

package/src/gRPC/ststest/protos/helloworld/HelloReply.ts

@@ -0,0 +1,10 @@
+// Original file: protos/helloworld.proto
+
+
+export interface HelloReply {
+  'message'?: (string);
+}
+
+export interface HelloReply__Output {
+  'message': (string);
+}

package/src/gRPC/ststest/protos/helloworld/HelloRequest.ts

@@ -0,0 +1,10 @@
+// Original file: protos/helloworld.proto
+
+
+export interface HelloRequest {
+  'name'?: (string);
+}
+
+export interface HelloRequest__Output {
+  'name': (string);
+}

package/src/gRPC/ststest/protos/helloworld.ts

@@ -0,0 +1,18 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import type * as grpc from '@grpc/grpc-js';
+import type { MessageTypeDefinition } from '@grpc/proto-loader';
+
+import type { GreeterClient as _helloworld_GreeterClient, GreeterDefinition as _helloworld_GreeterDefinition } from './helloworld/Greeter';
+
+type SubtypeConstructor<Constructor extends new (...args: any) => any, Subtype> = {
+  new(...args: ConstructorParameters<Constructor>): Subtype;
+};
+
+export interface ProtoGrpcType {
+  helloworld: {
+    Greeter: SubtypeConstructor<typeof grpc.Client, _helloworld_GreeterClient> & { service: _helloworld_GreeterDefinition }
+    HelloReply: MessageTypeDefinition
+    HelloRequest: MessageTypeDefinition
+  }
+}
+

package/src/gRPC/ststest/protos/keyvaluestore/KeyValueStore.ts

@@ -0,0 +1,23 @@
+// Original file: protos/keyvaluestore.proto
+
+import type * as grpc from '@grpc/grpc-js'
+import type { MethodDefinition } from '@grpc/proto-loader'
+import type { Request as _keyvaluestore_Request, Request__Output as _keyvaluestore_Request__Output } from '../keyvaluestore/Request';
+import type { Response as _keyvaluestore_Response, Response__Output as _keyvaluestore_Response__Output } from '../keyvaluestore/Response';
+
+export interface KeyValueStoreClient extends grpc.Client {
+  GetValues(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_keyvaluestore_Request, _keyvaluestore_Response__Output>;
+  GetValues(options?: grpc.CallOptions): grpc.ClientDuplexStream<_keyvaluestore_Request, _keyvaluestore_Response__Output>;
+  getValues(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_keyvaluestore_Request, _keyvaluestore_Response__Output>;
+  getValues(options?: grpc.CallOptions): grpc.ClientDuplexStream<_keyvaluestore_Request, _keyvaluestore_Response__Output>;
+  
+}
+
+export interface KeyValueStoreHandlers extends grpc.UntypedServiceImplementation {
+  GetValues: grpc.handleBidiStreamingCall<_keyvaluestore_Request__Output, _keyvaluestore_Response>;
+  
+}
+
+export interface KeyValueStoreDefinition extends grpc.ServiceDefinition {
+  GetValues: MethodDefinition<_keyvaluestore_Request, _keyvaluestore_Response, _keyvaluestore_Request__Output, _keyvaluestore_Response__Output>
+}

package/src/gRPC/ststest/protos/keyvaluestore/Request.ts

@@ -0,0 +1,10 @@
+// Original file: protos/keyvaluestore.proto
+
+
+export interface Request {
+  'key'?: (string);
+}
+
+export interface Request__Output {
+  'key': (string);
+}

package/src/gRPC/ststest/protos/keyvaluestore/Response.ts

@@ -0,0 +1,10 @@
+// Original file: protos/keyvaluestore.proto
+
+
+export interface Response {
+  'value'?: (string);
+}
+
+export interface Response__Output {
+  'value': (string);
+}

package/src/gRPC/ststest/protos/keyvaluestore.ts

@@ -0,0 +1,18 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import type * as grpc from '@grpc/grpc-js';
+import type { MessageTypeDefinition } from '@grpc/proto-loader';
+
+import type { KeyValueStoreClient as _keyvaluestore_KeyValueStoreClient, KeyValueStoreDefinition as _keyvaluestore_KeyValueStoreDefinition } from './keyvaluestore/KeyValueStore';
+
+type SubtypeConstructor<Constructor extends new (...args: any) => any, Subtype> = {
+  new(...args: ConstructorParameters<Constructor>): Subtype;
+};
+
+export interface ProtoGrpcType {
+  keyvaluestore: {
+    KeyValueStore: SubtypeConstructor<typeof grpc.Client, _keyvaluestore_KeyValueStoreClient> & { service: _keyvaluestore_KeyValueStoreDefinition }
+    Request: MessageTypeDefinition
+    Response: MessageTypeDefinition
+  }
+}
+

package/src/gRPC/ststest/protos/route_guide.ts

@@ -0,0 +1,21 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import type * as grpc from '@grpc/grpc-js';
+import type { MessageTypeDefinition } from '@grpc/proto-loader';
+
+import type { RouteGuideClient as _routeguide_RouteGuideClient, RouteGuideDefinition as _routeguide_RouteGuideDefinition } from './routeguide/RouteGuide';
+
+type SubtypeConstructor<Constructor extends new (...args: any) => any, Subtype> = {
+  new(...args: ConstructorParameters<Constructor>): Subtype;
+};
+
+export interface ProtoGrpcType {
+  routeguide: {
+    Feature: MessageTypeDefinition
+    Point: MessageTypeDefinition
+    Rectangle: MessageTypeDefinition
+    RouteGuide: SubtypeConstructor<typeof grpc.Client, _routeguide_RouteGuideClient> & { service: _routeguide_RouteGuideDefinition }
+    RouteNote: MessageTypeDefinition
+    RouteSummary: MessageTypeDefinition
+  }
+}
+

package/src/gRPC/ststest/protos/routeguide/Feature.ts

@@ -0,0 +1,13 @@
+// Original file: protos/route_guide.proto
+
+import type { Point as _routeguide_Point, Point__Output as _routeguide_Point__Output } from '../routeguide/Point';
+
+export interface Feature {
+  'name'?: (string);
+  'location'?: (_routeguide_Point | null);
+}
+
+export interface Feature__Output {
+  'name': (string);
+  'location': (_routeguide_Point__Output | null);
+}

package/src/gRPC/ststest/protos/routeguide/Point.ts

@@ -0,0 +1,12 @@
+// Original file: protos/route_guide.proto
+
+
+export interface Point {
+  'latitude'?: (number);
+  'longitude'?: (number);
+}
+
+export interface Point__Output {
+  'latitude': (number);
+  'longitude': (number);
+}

package/src/gRPC/ststest/protos/routeguide/Rectangle.ts

@@ -0,0 +1,13 @@
+// Original file: protos/route_guide.proto
+
+import type { Point as _routeguide_Point, Point__Output as _routeguide_Point__Output } from '../routeguide/Point';
+
+export interface Rectangle {
+  'lo'?: (_routeguide_Point | null);
+  'hi'?: (_routeguide_Point | null);
+}
+
+export interface Rectangle__Output {
+  'lo': (_routeguide_Point__Output | null);
+  'hi': (_routeguide_Point__Output | null);
+}

package/src/gRPC/ststest/protos/routeguide/RouteGuide.ts

@@ -0,0 +1,58 @@
+// Original file: protos/route_guide.proto
+
+import type * as grpc from '@grpc/grpc-js'
+import type { MethodDefinition } from '@grpc/proto-loader'
+import type { Feature as _routeguide_Feature, Feature__Output as _routeguide_Feature__Output } from '../routeguide/Feature';
+import type { Point as _routeguide_Point, Point__Output as _routeguide_Point__Output } from '../routeguide/Point';
+import type { Rectangle as _routeguide_Rectangle, Rectangle__Output as _routeguide_Rectangle__Output } from '../routeguide/Rectangle';
+import type { RouteNote as _routeguide_RouteNote, RouteNote__Output as _routeguide_RouteNote__Output } from '../routeguide/RouteNote';
+import type { RouteSummary as _routeguide_RouteSummary, RouteSummary__Output as _routeguide_RouteSummary__Output } from '../routeguide/RouteSummary';
+
+export interface RouteGuideClient extends grpc.Client {
+  GetFeature(argument: _routeguide_Point, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_routeguide_Feature__Output>): grpc.ClientUnaryCall;
+  GetFeature(argument: _routeguide_Point, metadata: grpc.Metadata, callback: grpc.requestCallback<_routeguide_Feature__Output>): grpc.ClientUnaryCall;
+  GetFeature(argument: _routeguide_Point, options: grpc.CallOptions, callback: grpc.requestCallback<_routeguide_Feature__Output>): grpc.ClientUnaryCall;
+  GetFeature(argument: _routeguide_Point, callback: grpc.requestCallback<_routeguide_Feature__Output>): grpc.ClientUnaryCall;
+  getFeature(argument: _routeguide_Point, metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_routeguide_Feature__Output>): grpc.ClientUnaryCall;
+  getFeature(argument: _routeguide_Point, metadata: grpc.Metadata, callback: grpc.requestCallback<_routeguide_Feature__Output>): grpc.ClientUnaryCall;
+  getFeature(argument: _routeguide_Point, options: grpc.CallOptions, callback: grpc.requestCallback<_routeguide_Feature__Output>): grpc.ClientUnaryCall;
+  getFeature(argument: _routeguide_Point, callback: grpc.requestCallback<_routeguide_Feature__Output>): grpc.ClientUnaryCall;
+  
+  ListFeatures(argument: _routeguide_Rectangle, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_routeguide_Feature__Output>;
+  ListFeatures(argument: _routeguide_Rectangle, options?: grpc.CallOptions): grpc.ClientReadableStream<_routeguide_Feature__Output>;
+  listFeatures(argument: _routeguide_Rectangle, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_routeguide_Feature__Output>;
+  listFeatures(argument: _routeguide_Rectangle, options?: grpc.CallOptions): grpc.ClientReadableStream<_routeguide_Feature__Output>;
+  
+  RecordRoute(metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_routeguide_RouteSummary__Output>): grpc.ClientWritableStream<_routeguide_Point>;
+  RecordRoute(metadata: grpc.Metadata, callback: grpc.requestCallback<_routeguide_RouteSummary__Output>): grpc.ClientWritableStream<_routeguide_Point>;
+  RecordRoute(options: grpc.CallOptions, callback: grpc.requestCallback<_routeguide_RouteSummary__Output>): grpc.ClientWritableStream<_routeguide_Point>;
+  RecordRoute(callback: grpc.requestCallback<_routeguide_RouteSummary__Output>): grpc.ClientWritableStream<_routeguide_Point>;
+  recordRoute(metadata: grpc.Metadata, options: grpc.CallOptions, callback: grpc.requestCallback<_routeguide_RouteSummary__Output>): grpc.ClientWritableStream<_routeguide_Point>;
+  recordRoute(metadata: grpc.Metadata, callback: grpc.requestCallback<_routeguide_RouteSummary__Output>): grpc.ClientWritableStream<_routeguide_Point>;
+  recordRoute(options: grpc.CallOptions, callback: grpc.requestCallback<_routeguide_RouteSummary__Output>): grpc.ClientWritableStream<_routeguide_Point>;
+  recordRoute(callback: grpc.requestCallback<_routeguide_RouteSummary__Output>): grpc.ClientWritableStream<_routeguide_Point>;
+  
+  RouteChat(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_routeguide_RouteNote, _routeguide_RouteNote__Output>;
+  RouteChat(options?: grpc.CallOptions): grpc.ClientDuplexStream<_routeguide_RouteNote, _routeguide_RouteNote__Output>;
+  routeChat(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_routeguide_RouteNote, _routeguide_RouteNote__Output>;
+  routeChat(options?: grpc.CallOptions): grpc.ClientDuplexStream<_routeguide_RouteNote, _routeguide_RouteNote__Output>;
+  
+}
+
+export interface RouteGuideHandlers extends grpc.UntypedServiceImplementation {
+  GetFeature: grpc.handleUnaryCall<_routeguide_Point__Output, _routeguide_Feature>;
+  
+  ListFeatures: grpc.handleServerStreamingCall<_routeguide_Rectangle__Output, _routeguide_Feature>;
+  
+  RecordRoute: grpc.handleClientStreamingCall<_routeguide_Point__Output, _routeguide_RouteSummary>;
+  
+  RouteChat: grpc.handleBidiStreamingCall<_routeguide_RouteNote__Output, _routeguide_RouteNote>;
+  
+}
+
+export interface RouteGuideDefinition extends grpc.ServiceDefinition {
+  GetFeature: MethodDefinition<_routeguide_Point, _routeguide_Feature, _routeguide_Point__Output, _routeguide_Feature__Output>
+  ListFeatures: MethodDefinition<_routeguide_Rectangle, _routeguide_Feature, _routeguide_Rectangle__Output, _routeguide_Feature__Output>
+  RecordRoute: MethodDefinition<_routeguide_Point, _routeguide_RouteSummary, _routeguide_Point__Output, _routeguide_RouteSummary__Output>
+  RouteChat: MethodDefinition<_routeguide_RouteNote, _routeguide_RouteNote, _routeguide_RouteNote__Output, _routeguide_RouteNote__Output>
+}

package/src/gRPC/ststest/protos/routeguide/RouteNote.ts

@@ -0,0 +1,13 @@
+// Original file: protos/route_guide.proto
+
+import type { Point as _routeguide_Point, Point__Output as _routeguide_Point__Output } from '../routeguide/Point';
+
+export interface RouteNote {
+  'location'?: (_routeguide_Point | null);
+  'message'?: (string);
+}
+
+export interface RouteNote__Output {
+  'location': (_routeguide_Point__Output | null);
+  'message': (string);
+}

package/src/gRPC/ststest/protos/routeguide/RouteSummary.ts

@@ -0,0 +1,16 @@
+// Original file: protos/route_guide.proto
+
+
+export interface RouteSummary {
+  'pointCount'?: (number);
+  'featureCount'?: (number);
+  'distance'?: (number);
+  'elapsedTime'?: (number);
+}
+
+export interface RouteSummary__Output {
+  'pointCount': (number);
+  'featureCount': (number);
+  'distance': (number);
+  'elapsedTime': (number);
+}

package/src/gRPC/ststest/src/route_guide_server2.ts

@@ -0,0 +1,211 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+
+// cd /home/marcusbettens/projects/stsappframework/src/gRPC/ststest
+// npx proto-loader-gen-types --longs=String --enums=String --defaults --oneofs --grpcLib=@grpc/grpc-js --outDir=protos/ protos/*.proto
+
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+const PROTO_PATH_SV = __dirname + './../../../../src/gRPC/ststest/protos/route_guide.proto';
+
+import * as grpc from '@grpc/grpc-js';
+import * as protoLoader from '@grpc/proto-loader';
+
+//import { IFeature, IPoint, IRectangle, IRouteNote, IRouteSummary } from './commonTypes'
+
+import chalk from 'chalk'
+
+import fs from 'node:fs'
+
+import { ProtoGrpcType } from './../protos/route_guide'
+
+import { RouteGuideHandlers } from './../protos/routeguide/RouteGuide'
+import { Point, Point__Output } from '../protos/routeguide/Point';
+import { Feature } from './../protos/routeguide/Feature'
+import { RouteSummary } from './../protos/routeguide/RouteSummary'
+import { RouteNote, RouteNote__Output } from './../protos/routeguide/RouteNote'
+
+const packageDefinition = protoLoader.loadSync(
+    PROTO_PATH_SV,
+    {keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true
+    });
+//const routeguide = grpc.loadPackageDefinition(packageDefinition).routeguide;
+
+const routeguide = (grpc.loadPackageDefinition(
+    packageDefinition
+) as unknown) as ProtoGrpcType;
+
+const exampleServer: RouteGuideHandlers = {
+    GetFeature(call, callback) {
+        console.log(chalk.grey(`getFeature: call.request: [${JSON.stringify(call.request)}]`));
+        const retVal = checkFeature(call.request);
+        console.log(chalk.grey(`getFeature: return: [${JSON.stringify(retVal)}]`));
+        callback(null, retVal);
+    },
+  
+    ListFeatures(call) {
+        console.log(chalk.green(`listFeatures: forEach: [${JSON.stringify(call.request)}]`));
+        const rectangle = call.request;
+        const lo = rectangle.lo;
+        const hi = rectangle.hi;
+    
+        const feature_list: Feature[] = [ ];
+        for (let i=0; i < 10; i++) {
+            feature_list.push({
+                location: {
+                    latitude: (hi as Point__Output).latitude * 2 * (i+1),
+                    longitude: (lo as Point__Output).longitude * 2 * (i+1)
+                },
+                name: `the name for index: [${i}]`
+            });
+        }
+        feature_list.forEach((feature: Feature) => {
+            console.log(chalk.green(`listFeatures: forEach: [${JSON.stringify(feature)}]`));
+            call.write(feature);
+        });
+        console.log(chalk.green(`listFeatures: call.end()`));
+        call.end();
+    },
+    
+    RecordRoute(call, callback) {
+        let point_count = 0;
+        let feature_count = 0;
+        let distance = 0;
+        let previous: any = null;
+        // Start a timer
+        const start_time = process.hrtime();
+        call.on('data', function(point: Point__Output) {
+            console.log(chalk.magenta(`recordRoute: on data: [${JSON.stringify(point)}]`));
+            point_count += 1;
+            if (checkFeature(point).name !== '') {
+                feature_count += 1;
+            }
+            /* For each point after the first, add the incremental distance from the
+         * previous point to the total distance value */
+            if (previous != null) {
+                distance += 1;
+            }
+            previous = point;
+        });
+        call.on('end', function() {
+            const returnData: RouteSummary = {
+                pointCount: point_count,
+                featureCount: feature_count,
+                // Cast the distance to an integer
+                distance: distance|0,
+                // End the timer
+                elapsedTime: process.hrtime(start_time)[0]
+            }
+            console.log(chalk.magenta(`recordRoute: on end - return data: [${JSON.stringify(returnData)}]`));
+            callback(null, returnData);
+        });
+    },
+    
+    RouteChat(call) {
+        call.on('data', function(note: RouteNote__Output) {
+            console.log(chalk.cyan(`routeChat: on data: [${JSON.stringify(note)}]`));
+            // Send back what we just got
+            const sendBack: RouteNote = JSON.parse(JSON.stringify(note));
+            sendBack.message = `${note.message} reply message`;
+            (sendBack.location as Point).latitude = (note.location as Point__Output).latitude * 2;
+            (sendBack.location as Point).longitude = (note.location as Point__Output).longitude * 2;
+            console.log(chalk.cyan(`routeChat: sending data: [${JSON.stringify(sendBack)}]`));
+            call.write(sendBack);
+        });
+        call.on('end', function() {
+            call.end();
+        });
+    }
+};
+
+/**
+ * Get a feature object at the given point, or creates one if it does not exist.
+ * @param {point} point The point to check
+ * @return {feature} The feature object at the point. Note that an empty name
+ *     indicates no feature
+ */
+function checkFeature(point: Point__Output): Feature {
+    const feature: Feature = {
+        name: "Some name",
+        location: {
+            latitude: point.latitude * 2,
+            longitude: point.longitude * 2
+        }
+    };
+    return feature;
+}
+
+/**
+ * Get a new server with the handler functions in this file bound to the methods
+ * it serves.
+ * @return {Server} The new server object
+ */
+function getServer() {
+    const server = new grpc.Server();
+    server.addService(routeguide.routeguide.RouteGuide.service, exampleServer);
+    return server;
+}
+
+// HTTPS_SERVER_KEY_PATH=/etc/letsencrypt/live/stsmda.org/privkey.pem \
+// HTTPS_SERVER_CERT_PATH=/etc/letsencrypt/live/stsmda.org/fullchain.pem \
+
+/*
+export interface KeyCertPair {
+    private_key: Buffer;
+    cert_chain: Buffer;
+}
+*/
+
+if (require.main === module) {
+    // If this is run as a script, start a server on an unused port
+    const routeServer = getServer();
+    
+    // Secure server
+
+    routeServer.bindAsync('0.0.0.0:3029', grpc.ServerCredentials.createSsl(null,
+        [
+            {
+                private_key: fs.readFileSync('/etc/letsencrypt/live/stsmda.org/privkey.pem'),
+                cert_chain: fs.readFileSync('/etc/letsencrypt/live/stsmda.org/fullchain.pem')
+            }
+        ]), (error, port) => {
+        if (error) {
+            console.log(chalk.red(`Error starting gRPC TLS server on port: [${port}], Error: [${error}]`));
+        } else {
+            console.log(chalk.green(`Started gRPC TLS server on port: [${port}]`));
+        }
+    });
+
+    // Insecure server
+    /*
+    routeServer.bindAsync('0.0.0.0:3029', grpc.ServerCredentials.createInsecure(),
+        (error, port) => {
+            if (error) {
+                console.log(chalk.red(`Error starting gRPC TLS server on port: [${port}], Error: [${error}]`));
+            } else {
+                console.log(chalk.green(`Started gRPC TLS server on port: [${port}]`));
+            }
+        });
+        */
+}
+
+exports.getServer = getServer;