examplepb

package
v2.9.4 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 12, 2022 License: BSD-3-Clause Imports: 28 Imported by: 0

Documentation

Overview

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package examplepb is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

This section is empty.

Variables

View Source
var (
	NumericEnum_name = map[int32]string{
		0: "ZERO",
		1: "ONE",
	}
	NumericEnum_value = map[string]int32{
		"ZERO": 0,
		"ONE":  1,
	}
)

Enum value maps for NumericEnum.

View Source
var (
	ABitOfEverything_Nested_DeepEnum_name = map[int32]string{
		0: "FALSE",
		1: "TRUE",
	}
	ABitOfEverything_Nested_DeepEnum_value = map[string]int32{
		"FALSE": 0,
		"TRUE":  1,
	}
)

Enum value maps for ABitOfEverything_Nested_DeepEnum.

View Source
var (
	RepeatedResponseBodyOut_Response_ResponseType_name = map[int32]string{
		0: "UNKNOWN",
		1: "A",
		2: "B",
	}
	RepeatedResponseBodyOut_Response_ResponseType_value = map[string]int32{
		"UNKNOWN": 0,
		"A":       1,
		"B":       2,
	}
)

Enum value maps for RepeatedResponseBodyOut_Response_ResponseType.

View Source
var ABitOfEverythingService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService",
	HandlerType: (*ABitOfEverythingServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _ABitOfEverythingService_Create_Handler,
		},
		{
			MethodName: "CreateBody",
			Handler:    _ABitOfEverythingService_CreateBody_Handler,
		},
		{
			MethodName: "CreateBook",
			Handler:    _ABitOfEverythingService_CreateBook_Handler,
		},
		{
			MethodName: "UpdateBook",
			Handler:    _ABitOfEverythingService_UpdateBook_Handler,
		},
		{
			MethodName: "Lookup",
			Handler:    _ABitOfEverythingService_Lookup_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _ABitOfEverythingService_Update_Handler,
		},
		{
			MethodName: "UpdateV2",
			Handler:    _ABitOfEverythingService_UpdateV2_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _ABitOfEverythingService_Delete_Handler,
		},
		{
			MethodName: "GetQuery",
			Handler:    _ABitOfEverythingService_GetQuery_Handler,
		},
		{
			MethodName: "GetRepeatedQuery",
			Handler:    _ABitOfEverythingService_GetRepeatedQuery_Handler,
		},
		{
			MethodName: "Echo",
			Handler:    _ABitOfEverythingService_Echo_Handler,
		},
		{
			MethodName: "DeepPathEcho",
			Handler:    _ABitOfEverythingService_DeepPathEcho_Handler,
		},
		{
			MethodName: "NoBindings",
			Handler:    _ABitOfEverythingService_NoBindings_Handler,
		},
		{
			MethodName: "Timeout",
			Handler:    _ABitOfEverythingService_Timeout_Handler,
		},
		{
			MethodName: "ErrorWithDetails",
			Handler:    _ABitOfEverythingService_ErrorWithDetails_Handler,
		},
		{
			MethodName: "GetMessageWithBody",
			Handler:    _ABitOfEverythingService_GetMessageWithBody_Handler,
		},
		{
			MethodName: "PostWithEmptyBody",
			Handler:    _ABitOfEverythingService_PostWithEmptyBody_Handler,
		},
		{
			MethodName: "CheckGetQueryParams",
			Handler:    _ABitOfEverythingService_CheckGetQueryParams_Handler,
		},
		{
			MethodName: "CheckNestedEnumGetQueryParams",
			Handler:    _ABitOfEverythingService_CheckNestedEnumGetQueryParams_Handler,
		},
		{
			MethodName: "CheckPostQueryParams",
			Handler:    _ABitOfEverythingService_CheckPostQueryParams_Handler,
		},
		{
			MethodName: "OverwriteResponseContentType",
			Handler:    _ABitOfEverythingService_OverwriteResponseContentType_Handler,
		},
		{
			MethodName: "CheckExternalPathEnum",
			Handler:    _ABitOfEverythingService_CheckExternalPathEnum_Handler,
		},
		{
			MethodName: "CheckExternalNestedPathEnum",
			Handler:    _ABitOfEverythingService_CheckExternalNestedPathEnum_Handler,
		},
		{
			MethodName: "CheckStatus",
			Handler:    _ABitOfEverythingService_CheckStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/a_bit_of_everything.proto",
}

ABitOfEverythingService_ServiceDesc is the grpc.ServiceDesc for ABitOfEverythingService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var AnotherServiceWithNoBindings_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.AnotherServiceWithNoBindings",
	HandlerType: (*AnotherServiceWithNoBindingsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "NoBindings",
			Handler:    _AnotherServiceWithNoBindings_NoBindings_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/a_bit_of_everything.proto",
}

AnotherServiceWithNoBindings_ServiceDesc is the grpc.ServiceDesc for AnotherServiceWithNoBindings service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var CamelCaseServiceName_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.camelCaseServiceName",
	HandlerType: (*CamelCaseServiceNameServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Empty",
			Handler:    _CamelCaseServiceName_Empty_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/a_bit_of_everything.proto",
}

CamelCaseServiceName_ServiceDesc is the grpc.ServiceDesc for CamelCaseServiceName service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var EchoService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.EchoService",
	HandlerType: (*EchoServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Echo",
			Handler:    _EchoService_Echo_Handler,
		},
		{
			MethodName: "EchoBody",
			Handler:    _EchoService_EchoBody_Handler,
		},
		{
			MethodName: "EchoDelete",
			Handler:    _EchoService_EchoDelete_Handler,
		},
		{
			MethodName: "EchoPatch",
			Handler:    _EchoService_EchoPatch_Handler,
		},
		{
			MethodName: "EchoUnauthorized",
			Handler:    _EchoService_EchoUnauthorized_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/echo_service.proto",
}

EchoService_ServiceDesc is the grpc.ServiceDesc for EchoService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var File_examples_internal_proto_examplepb_a_bit_of_everything_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_echo_service_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_flow_combination_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_generate_unbound_methods_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_non_standard_names_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_openapi_merge_a_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_openapi_merge_b_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_response_body_service_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_stream_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_unannotated_echo_service_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_use_go_template_proto protoreflect.FileDescriptor
View Source
var File_examples_internal_proto_examplepb_wrappers_proto protoreflect.FileDescriptor
View Source
var FlowCombination_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.FlowCombination",
	HandlerType: (*FlowCombinationServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RpcEmptyRpc",
			Handler:    _FlowCombination_RpcEmptyRpc_Handler,
		},
		{
			MethodName: "RpcBodyRpc",
			Handler:    _FlowCombination_RpcBodyRpc_Handler,
		},
		{
			MethodName: "RpcPathSingleNestedRpc",
			Handler:    _FlowCombination_RpcPathSingleNestedRpc_Handler,
		},
		{
			MethodName: "RpcPathNestedRpc",
			Handler:    _FlowCombination_RpcPathNestedRpc_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RpcEmptyStream",
			Handler:       _FlowCombination_RpcEmptyStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamEmptyRpc",
			Handler:       _FlowCombination_StreamEmptyRpc_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "StreamEmptyStream",
			Handler:       _FlowCombination_StreamEmptyStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "RpcBodyStream",
			Handler:       _FlowCombination_RpcBodyStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RpcPathSingleNestedStream",
			Handler:       _FlowCombination_RpcPathSingleNestedStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RpcPathNestedStream",
			Handler:       _FlowCombination_RpcPathNestedStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "examples/internal/proto/examplepb/flow_combination.proto",
}

FlowCombination_ServiceDesc is the grpc.ServiceDesc for FlowCombination service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var GenerateUnboundMethodsEchoService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.GenerateUnboundMethodsEchoService",
	HandlerType: (*GenerateUnboundMethodsEchoServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Echo",
			Handler:    _GenerateUnboundMethodsEchoService_Echo_Handler,
		},
		{
			MethodName: "EchoBody",
			Handler:    _GenerateUnboundMethodsEchoService_EchoBody_Handler,
		},
		{
			MethodName: "EchoDelete",
			Handler:    _GenerateUnboundMethodsEchoService_EchoDelete_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/generate_unbound_methods.proto",
}

GenerateUnboundMethodsEchoService_ServiceDesc is the grpc.ServiceDesc for GenerateUnboundMethodsEchoService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var LoginService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.LoginService",
	HandlerType: (*LoginServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Login",
			Handler:    _LoginService_Login_Handler,
		},
		{
			MethodName: "Logout",
			Handler:    _LoginService_Logout_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/use_go_template.proto",
}

LoginService_ServiceDesc is the grpc.ServiceDesc for LoginService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var NonStandardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.NonStandardService",
	HandlerType: (*NonStandardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Update",
			Handler:    _NonStandardService_Update_Handler,
		},
		{
			MethodName: "UpdateWithJSONNames",
			Handler:    _NonStandardService_UpdateWithJSONNames_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/non_standard_names.proto",
}

NonStandardService_ServiceDesc is the grpc.ServiceDesc for NonStandardService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var ResponseBodyService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService",
	HandlerType: (*ResponseBodyServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetResponseBody",
			Handler:    _ResponseBodyService_GetResponseBody_Handler,
		},
		{
			MethodName: "ListResponseBodies",
			Handler:    _ResponseBodyService_ListResponseBodies_Handler,
		},
		{
			MethodName: "ListResponseStrings",
			Handler:    _ResponseBodyService_ListResponseStrings_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetResponseBodyStream",
			Handler:       _ResponseBodyService_GetResponseBodyStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "examples/internal/proto/examplepb/response_body_service.proto",
}

ResponseBodyService_ServiceDesc is the grpc.ServiceDesc for ResponseBodyService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var ServiceA_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.examplepb.ServiceA",
	HandlerType: (*ServiceAServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "MethodOne",
			Handler:    _ServiceA_MethodOne_Handler,
		},
		{
			MethodName: "MethodTwo",
			Handler:    _ServiceA_MethodTwo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/openapi_merge_a.proto",
}

ServiceA_ServiceDesc is the grpc.ServiceDesc for ServiceA service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var ServiceB_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.examplepb.ServiceB",
	HandlerType: (*ServiceBServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "MethodOne",
			Handler:    _ServiceB_MethodOne_Handler,
		},
		{
			MethodName: "MethodTwo",
			Handler:    _ServiceB_MethodTwo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/openapi_merge_b.proto",
}

ServiceB_ServiceDesc is the grpc.ServiceDesc for ServiceB service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var ServiceC_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.examplepb.ServiceC",
	HandlerType: (*ServiceCServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "MethodOne",
			Handler:    _ServiceC_MethodOne_Handler,
		},
		{
			MethodName: "MethodTwo",
			Handler:    _ServiceC_MethodTwo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/openapi_merge_a.proto",
}

ServiceC_ServiceDesc is the grpc.ServiceDesc for ServiceC service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var StreamService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.StreamService",
	HandlerType: (*StreamServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "BulkCreate",
			Handler:       _StreamService_BulkCreate_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "List",
			Handler:       _StreamService_List_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "BulkEcho",
			Handler:       _StreamService_BulkEcho_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Download",
			Handler:       _StreamService_Download_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "examples/internal/proto/examplepb/stream.proto",
}

StreamService_ServiceDesc is the grpc.ServiceDesc for StreamService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var UnannotatedEchoService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.UnannotatedEchoService",
	HandlerType: (*UnannotatedEchoServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Echo",
			Handler:    _UnannotatedEchoService_Echo_Handler,
		},
		{
			MethodName: "EchoBody",
			Handler:    _UnannotatedEchoService_EchoBody_Handler,
		},
		{
			MethodName: "EchoDelete",
			Handler:    _UnannotatedEchoService_EchoDelete_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/unannotated_echo_service.proto",
}

UnannotatedEchoService_ServiceDesc is the grpc.ServiceDesc for UnannotatedEchoService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source
var WrappersService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.WrappersService",
	HandlerType: (*WrappersServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _WrappersService_Create_Handler,
		},
		{
			MethodName: "CreateStringValue",
			Handler:    _WrappersService_CreateStringValue_Handler,
		},
		{
			MethodName: "CreateInt32Value",
			Handler:    _WrappersService_CreateInt32Value_Handler,
		},
		{
			MethodName: "CreateInt64Value",
			Handler:    _WrappersService_CreateInt64Value_Handler,
		},
		{
			MethodName: "CreateFloatValue",
			Handler:    _WrappersService_CreateFloatValue_Handler,
		},
		{
			MethodName: "CreateDoubleValue",
			Handler:    _WrappersService_CreateDoubleValue_Handler,
		},
		{
			MethodName: "CreateBoolValue",
			Handler:    _WrappersService_CreateBoolValue_Handler,
		},
		{
			MethodName: "CreateUInt32Value",
			Handler:    _WrappersService_CreateUInt32Value_Handler,
		},
		{
			MethodName: "CreateUInt64Value",
			Handler:    _WrappersService_CreateUInt64Value_Handler,
		},
		{
			MethodName: "CreateBytesValue",
			Handler:    _WrappersService_CreateBytesValue_Handler,
		},
		{
			MethodName: "CreateEmpty",
			Handler:    _WrappersService_CreateEmpty_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/wrappers.proto",
}

WrappersService_ServiceDesc is the grpc.ServiceDesc for WrappersService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

Functions

func RegisterABitOfEverythingServiceHandler

func RegisterABitOfEverythingServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterABitOfEverythingServiceHandler registers the http handlers for service ABitOfEverythingService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterABitOfEverythingServiceHandlerClient

func RegisterABitOfEverythingServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ABitOfEverythingServiceClient) error

RegisterABitOfEverythingServiceHandlerClient registers the http handlers for service ABitOfEverythingService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ABitOfEverythingServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ABitOfEverythingServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ABitOfEverythingServiceClient" to call the correct interceptors.

func RegisterABitOfEverythingServiceHandlerFromEndpoint

func RegisterABitOfEverythingServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterABitOfEverythingServiceHandlerFromEndpoint is same as RegisterABitOfEverythingServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterABitOfEverythingServiceHandlerServer

func RegisterABitOfEverythingServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ABitOfEverythingServiceServer) error

RegisterABitOfEverythingServiceHandlerServer registers the http handlers for service ABitOfEverythingService to "mux". UnaryRPC :call ABitOfEverythingServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterABitOfEverythingServiceHandlerFromEndpoint instead.

func RegisterABitOfEverythingServiceServer

func RegisterABitOfEverythingServiceServer(s grpc.ServiceRegistrar, srv ABitOfEverythingServiceServer)

func RegisterAnotherServiceWithNoBindingsServer

func RegisterAnotherServiceWithNoBindingsServer(s grpc.ServiceRegistrar, srv AnotherServiceWithNoBindingsServer)

func RegisterCamelCaseServiceNameHandler

func RegisterCamelCaseServiceNameHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCamelCaseServiceNameHandler registers the http handlers for service CamelCaseServiceName to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCamelCaseServiceNameHandlerClient

func RegisterCamelCaseServiceNameHandlerClient(ctx context.Context, mux *runtime.ServeMux, client CamelCaseServiceNameClient) error

RegisterCamelCaseServiceNameHandlerClient registers the http handlers for service CamelCaseServiceName to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "CamelCaseServiceNameClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "CamelCaseServiceNameClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "CamelCaseServiceNameClient" to call the correct interceptors.

func RegisterCamelCaseServiceNameHandlerFromEndpoint

func RegisterCamelCaseServiceNameHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCamelCaseServiceNameHandlerFromEndpoint is same as RegisterCamelCaseServiceNameHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCamelCaseServiceNameHandlerServer

func RegisterCamelCaseServiceNameHandlerServer(ctx context.Context, mux *runtime.ServeMux, server CamelCaseServiceNameServer) error

RegisterCamelCaseServiceNameHandlerServer registers the http handlers for service CamelCaseServiceName to "mux". UnaryRPC :call CamelCaseServiceNameServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCamelCaseServiceNameHandlerFromEndpoint instead.

func RegisterCamelCaseServiceNameServer

func RegisterCamelCaseServiceNameServer(s grpc.ServiceRegistrar, srv CamelCaseServiceNameServer)

func RegisterEchoServiceHandler

func RegisterEchoServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterEchoServiceHandler registers the http handlers for service EchoService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterEchoServiceHandlerClient

func RegisterEchoServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client EchoServiceClient) error

RegisterEchoServiceHandlerClient registers the http handlers for service EchoService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "EchoServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "EchoServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "EchoServiceClient" to call the correct interceptors.

func RegisterEchoServiceHandlerFromEndpoint

func RegisterEchoServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterEchoServiceHandlerFromEndpoint is same as RegisterEchoServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterEchoServiceHandlerServer

func RegisterEchoServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server EchoServiceServer) error

RegisterEchoServiceHandlerServer registers the http handlers for service EchoService to "mux". UnaryRPC :call EchoServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterEchoServiceHandlerFromEndpoint instead.

func RegisterEchoServiceServer

func RegisterEchoServiceServer(s grpc.ServiceRegistrar, srv EchoServiceServer)

func RegisterFlowCombinationHandler

func RegisterFlowCombinationHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterFlowCombinationHandler registers the http handlers for service FlowCombination to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterFlowCombinationHandlerClient

func RegisterFlowCombinationHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FlowCombinationClient) error

RegisterFlowCombinationHandlerClient registers the http handlers for service FlowCombination to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "FlowCombinationClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "FlowCombinationClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "FlowCombinationClient" to call the correct interceptors.

func RegisterFlowCombinationHandlerFromEndpoint

func RegisterFlowCombinationHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterFlowCombinationHandlerFromEndpoint is same as RegisterFlowCombinationHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterFlowCombinationHandlerServer

func RegisterFlowCombinationHandlerServer(ctx context.Context, mux *runtime.ServeMux, server FlowCombinationServer) error

RegisterFlowCombinationHandlerServer registers the http handlers for service FlowCombination to "mux". UnaryRPC :call FlowCombinationServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterFlowCombinationHandlerFromEndpoint instead.

func RegisterFlowCombinationServer

func RegisterFlowCombinationServer(s grpc.ServiceRegistrar, srv FlowCombinationServer)

func RegisterGenerateUnboundMethodsEchoServiceHandler

func RegisterGenerateUnboundMethodsEchoServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterGenerateUnboundMethodsEchoServiceHandler registers the http handlers for service GenerateUnboundMethodsEchoService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterGenerateUnboundMethodsEchoServiceHandlerClient

func RegisterGenerateUnboundMethodsEchoServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client GenerateUnboundMethodsEchoServiceClient) error

RegisterGenerateUnboundMethodsEchoServiceHandlerClient registers the http handlers for service GenerateUnboundMethodsEchoService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "GenerateUnboundMethodsEchoServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "GenerateUnboundMethodsEchoServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "GenerateUnboundMethodsEchoServiceClient" to call the correct interceptors.

func RegisterGenerateUnboundMethodsEchoServiceHandlerFromEndpoint

func RegisterGenerateUnboundMethodsEchoServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterGenerateUnboundMethodsEchoServiceHandlerFromEndpoint is same as RegisterGenerateUnboundMethodsEchoServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterGenerateUnboundMethodsEchoServiceHandlerServer

func RegisterGenerateUnboundMethodsEchoServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server GenerateUnboundMethodsEchoServiceServer) error

RegisterGenerateUnboundMethodsEchoServiceHandlerServer registers the http handlers for service GenerateUnboundMethodsEchoService to "mux". UnaryRPC :call GenerateUnboundMethodsEchoServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterGenerateUnboundMethodsEchoServiceHandlerFromEndpoint instead.

func RegisterGenerateUnboundMethodsEchoServiceServer

func RegisterGenerateUnboundMethodsEchoServiceServer(s grpc.ServiceRegistrar, srv GenerateUnboundMethodsEchoServiceServer)

func RegisterLoginServiceHandler

func RegisterLoginServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterLoginServiceHandler registers the http handlers for service LoginService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterLoginServiceHandlerClient

func RegisterLoginServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client LoginServiceClient) error

RegisterLoginServiceHandlerClient registers the http handlers for service LoginService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LoginServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LoginServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "LoginServiceClient" to call the correct interceptors.

func RegisterLoginServiceHandlerFromEndpoint

func RegisterLoginServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterLoginServiceHandlerFromEndpoint is same as RegisterLoginServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterLoginServiceHandlerServer

func RegisterLoginServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server LoginServiceServer) error

RegisterLoginServiceHandlerServer registers the http handlers for service LoginService to "mux". UnaryRPC :call LoginServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterLoginServiceHandlerFromEndpoint instead.

func RegisterLoginServiceServer

func RegisterLoginServiceServer(s grpc.ServiceRegistrar, srv LoginServiceServer)

func RegisterNonStandardServiceHandler

func RegisterNonStandardServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNonStandardServiceHandler registers the http handlers for service NonStandardService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNonStandardServiceHandlerClient

func RegisterNonStandardServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NonStandardServiceClient) error

RegisterNonStandardServiceHandlerClient registers the http handlers for service NonStandardService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NonStandardServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NonStandardServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NonStandardServiceClient" to call the correct interceptors.

func RegisterNonStandardServiceHandlerFromEndpoint

func RegisterNonStandardServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNonStandardServiceHandlerFromEndpoint is same as RegisterNonStandardServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNonStandardServiceHandlerServer

func RegisterNonStandardServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NonStandardServiceServer) error

RegisterNonStandardServiceHandlerServer registers the http handlers for service NonStandardService to "mux". UnaryRPC :call NonStandardServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterNonStandardServiceHandlerFromEndpoint instead.

func RegisterNonStandardServiceServer

func RegisterNonStandardServiceServer(s grpc.ServiceRegistrar, srv NonStandardServiceServer)

func RegisterResponseBodyServiceHandler

func RegisterResponseBodyServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterResponseBodyServiceHandler registers the http handlers for service ResponseBodyService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterResponseBodyServiceHandlerClient

func RegisterResponseBodyServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ResponseBodyServiceClient) error

RegisterResponseBodyServiceHandlerClient registers the http handlers for service ResponseBodyService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ResponseBodyServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ResponseBodyServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ResponseBodyServiceClient" to call the correct interceptors.

func RegisterResponseBodyServiceHandlerFromEndpoint

func RegisterResponseBodyServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterResponseBodyServiceHandlerFromEndpoint is same as RegisterResponseBodyServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterResponseBodyServiceHandlerServer

func RegisterResponseBodyServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ResponseBodyServiceServer) error

RegisterResponseBodyServiceHandlerServer registers the http handlers for service ResponseBodyService to "mux". UnaryRPC :call ResponseBodyServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterResponseBodyServiceHandlerFromEndpoint instead.

func RegisterResponseBodyServiceServer

func RegisterResponseBodyServiceServer(s grpc.ServiceRegistrar, srv ResponseBodyServiceServer)

func RegisterServiceAHandler

func RegisterServiceAHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterServiceAHandler registers the http handlers for service ServiceA to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterServiceAHandlerClient

func RegisterServiceAHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServiceAClient) error

RegisterServiceAHandlerClient registers the http handlers for service ServiceA to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServiceAClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServiceAClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ServiceAClient" to call the correct interceptors.

func RegisterServiceAHandlerFromEndpoint

func RegisterServiceAHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterServiceAHandlerFromEndpoint is same as RegisterServiceAHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterServiceAHandlerServer

func RegisterServiceAHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServiceAServer) error

RegisterServiceAHandlerServer registers the http handlers for service ServiceA to "mux". UnaryRPC :call ServiceAServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServiceAHandlerFromEndpoint instead.

func RegisterServiceAServer

func RegisterServiceAServer(s grpc.ServiceRegistrar, srv ServiceAServer)

func RegisterServiceBHandler

func RegisterServiceBHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterServiceBHandler registers the http handlers for service ServiceB to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterServiceBHandlerClient

func RegisterServiceBHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServiceBClient) error

RegisterServiceBHandlerClient registers the http handlers for service ServiceB to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServiceBClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServiceBClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ServiceBClient" to call the correct interceptors.

func RegisterServiceBHandlerFromEndpoint

func RegisterServiceBHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterServiceBHandlerFromEndpoint is same as RegisterServiceBHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterServiceBHandlerServer

func RegisterServiceBHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServiceBServer) error

RegisterServiceBHandlerServer registers the http handlers for service ServiceB to "mux". UnaryRPC :call ServiceBServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServiceBHandlerFromEndpoint instead.

func RegisterServiceBServer

func RegisterServiceBServer(s grpc.ServiceRegistrar, srv ServiceBServer)

func RegisterServiceCHandler

func RegisterServiceCHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterServiceCHandler registers the http handlers for service ServiceC to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterServiceCHandlerClient

func RegisterServiceCHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServiceCClient) error

RegisterServiceCHandlerClient registers the http handlers for service ServiceC to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServiceCClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServiceCClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ServiceCClient" to call the correct interceptors.

func RegisterServiceCHandlerFromEndpoint

func RegisterServiceCHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterServiceCHandlerFromEndpoint is same as RegisterServiceCHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterServiceCHandlerServer

func RegisterServiceCHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServiceCServer) error

RegisterServiceCHandlerServer registers the http handlers for service ServiceC to "mux". UnaryRPC :call ServiceCServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServiceCHandlerFromEndpoint instead.

func RegisterServiceCServer

func RegisterServiceCServer(s grpc.ServiceRegistrar, srv ServiceCServer)

func RegisterStreamServiceHandler

func RegisterStreamServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterStreamServiceHandler registers the http handlers for service StreamService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterStreamServiceHandlerClient

func RegisterStreamServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client StreamServiceClient) error

RegisterStreamServiceHandlerClient registers the http handlers for service StreamService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "StreamServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "StreamServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "StreamServiceClient" to call the correct interceptors.

func RegisterStreamServiceHandlerFromEndpoint

func RegisterStreamServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterStreamServiceHandlerFromEndpoint is same as RegisterStreamServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterStreamServiceHandlerServer

func RegisterStreamServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server StreamServiceServer) error

RegisterStreamServiceHandlerServer registers the http handlers for service StreamService to "mux". UnaryRPC :call StreamServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterStreamServiceHandlerFromEndpoint instead.

func RegisterStreamServiceServer

func RegisterStreamServiceServer(s grpc.ServiceRegistrar, srv StreamServiceServer)

func RegisterUnannotatedEchoServiceHandler

func RegisterUnannotatedEchoServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterUnannotatedEchoServiceHandler registers the http handlers for service UnannotatedEchoService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterUnannotatedEchoServiceHandlerClient

func RegisterUnannotatedEchoServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client UnannotatedEchoServiceClient) error

RegisterUnannotatedEchoServiceHandlerClient registers the http handlers for service UnannotatedEchoService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "UnannotatedEchoServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "UnannotatedEchoServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "UnannotatedEchoServiceClient" to call the correct interceptors.

func RegisterUnannotatedEchoServiceHandlerFromEndpoint

func RegisterUnannotatedEchoServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterUnannotatedEchoServiceHandlerFromEndpoint is same as RegisterUnannotatedEchoServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterUnannotatedEchoServiceHandlerServer

func RegisterUnannotatedEchoServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server UnannotatedEchoServiceServer) error

RegisterUnannotatedEchoServiceHandlerServer registers the http handlers for service UnannotatedEchoService to "mux". UnaryRPC :call UnannotatedEchoServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterUnannotatedEchoServiceHandlerFromEndpoint instead.

func RegisterUnannotatedEchoServiceServer

func RegisterUnannotatedEchoServiceServer(s grpc.ServiceRegistrar, srv UnannotatedEchoServiceServer)

func RegisterWrappersServiceHandler

func RegisterWrappersServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterWrappersServiceHandler registers the http handlers for service WrappersService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterWrappersServiceHandlerClient

func RegisterWrappersServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client WrappersServiceClient) error

RegisterWrappersServiceHandlerClient registers the http handlers for service WrappersService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "WrappersServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WrappersServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "WrappersServiceClient" to call the correct interceptors.

func RegisterWrappersServiceHandlerFromEndpoint

func RegisterWrappersServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterWrappersServiceHandlerFromEndpoint is same as RegisterWrappersServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterWrappersServiceHandlerServer

func RegisterWrappersServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server WrappersServiceServer) error

RegisterWrappersServiceHandlerServer registers the http handlers for service WrappersService to "mux". UnaryRPC :call WrappersServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterWrappersServiceHandlerFromEndpoint instead.

func RegisterWrappersServiceServer

func RegisterWrappersServiceServer(s grpc.ServiceRegistrar, srv WrappersServiceServer)

Types

type ABitOfEverything

type ABitOfEverything struct {
	SingleNested        *ABitOfEverything_Nested                `protobuf:"bytes,25,opt,name=single_nested,json=singleNested,proto3" json:"single_nested,omitempty"`
	Uuid                string                                  `protobuf:"bytes,1,opt,name=uuid,proto3" json:"uuid,omitempty"`
	Nested              []*ABitOfEverything_Nested              `protobuf:"bytes,2,rep,name=nested,proto3" json:"nested,omitempty"`
	FloatValue          float32                                 `protobuf:"fixed32,3,opt,name=float_value,json=floatValue,proto3" json:"float_value,omitempty"`
	DoubleValue         float64                                 `protobuf:"fixed64,4,opt,name=double_value,json=doubleValue,proto3" json:"double_value,omitempty"`
	Int64Value          int64                                   `protobuf:"varint,5,opt,name=int64_value,json=int64Value,proto3" json:"int64_value,omitempty"`
	Uint64Value         uint64                                  `protobuf:"varint,6,opt,name=uint64_value,json=uint64Value,proto3" json:"uint64_value,omitempty"`
	Int32Value          int32                                   `protobuf:"varint,7,opt,name=int32_value,json=int32Value,proto3" json:"int32_value,omitempty"`
	Fixed64Value        uint64                                  `protobuf:"fixed64,8,opt,name=fixed64_value,json=fixed64Value,proto3" json:"fixed64_value,omitempty"`
	Fixed32Value        uint32                                  `protobuf:"fixed32,9,opt,name=fixed32_value,json=fixed32Value,proto3" json:"fixed32_value,omitempty"`
	BoolValue           bool                                    `protobuf:"varint,10,opt,name=bool_value,json=boolValue,proto3" json:"bool_value,omitempty"`
	StringValue         string                                  `protobuf:"bytes,11,opt,name=string_value,json=stringValue,proto3" json:"string_value,omitempty"`
	BytesValue          []byte                                  `protobuf:"bytes,29,opt,name=bytes_value,json=bytesValue,proto3" json:"bytes_value,omitempty"`
	Uint32Value         uint32                                  `protobuf:"varint,13,opt,name=uint32_value,json=uint32Value,proto3" json:"uint32_value,omitempty"`
	EnumValue           NumericEnum                             `` /* 154-byte string literal not displayed */
	PathEnumValue       pathenum.PathEnum                       `` /* 158-byte string literal not displayed */
	NestedPathEnumValue pathenum.MessagePathEnum_NestedPathEnum `` /* 200-byte string literal not displayed */
	Sfixed32Value       int32                                   `protobuf:"fixed32,15,opt,name=sfixed32_value,json=sfixed32Value,proto3" json:"sfixed32_value,omitempty"`
	Sfixed64Value       int64                                   `protobuf:"fixed64,16,opt,name=sfixed64_value,json=sfixed64Value,proto3" json:"sfixed64_value,omitempty"`
	Sint32Value         int32                                   `protobuf:"zigzag32,17,opt,name=sint32_value,json=sint32Value,proto3" json:"sint32_value,omitempty"`
	Sint64Value         int64                                   `protobuf:"zigzag64,18,opt,name=sint64_value,json=sint64Value,proto3" json:"sint64_value,omitempty"`
	RepeatedStringValue []string                                `protobuf:"bytes,19,rep,name=repeated_string_value,json=repeatedStringValue,proto3" json:"repeated_string_value,omitempty"`
	// Types that are assignable to OneofValue:
	//	*ABitOfEverything_OneofEmpty
	//	*ABitOfEverything_OneofString
	OneofValue               isABitOfEverything_OneofValue       `protobuf_oneof:"oneof_value"`
	MapValue                 map[string]NumericEnum              `` /* 239-byte string literal not displayed */
	MappedStringValue        map[string]string                   `` /* 203-byte string literal not displayed */
	MappedNestedValue        map[string]*ABitOfEverything_Nested `` /* 203-byte string literal not displayed */
	NonConventionalNameValue string                              `protobuf:"bytes,26,opt,name=nonConventionalNameValue,proto3" json:"nonConventionalNameValue,omitempty"`
	TimestampValue           *timestamppb.Timestamp              `protobuf:"bytes,27,opt,name=timestamp_value,json=timestampValue,proto3" json:"timestamp_value,omitempty"`
	// repeated enum value. it is comma-separated in query
	RepeatedEnumValue []NumericEnum `` /* 187-byte string literal not displayed */
	// repeated numeric enum comment (This comment is overridden by the field annotation)
	RepeatedEnumAnnotation []NumericEnum `` /* 202-byte string literal not displayed */
	// numeric enum comment (This comment is overridden by the field annotation)
	EnumValueAnnotation NumericEnum `` /* 186-byte string literal not displayed */
	// repeated string comment (This comment is overridden by the field annotation)
	RepeatedStringAnnotation []string `` /* 136-byte string literal not displayed */
	// repeated nested object comment (This comment is overridden by the field annotation)
	RepeatedNestedAnnotation []*ABitOfEverything_Nested `` /* 136-byte string literal not displayed */
	// nested object comments (This comment is overridden by the field annotation)
	NestedAnnotation  *ABitOfEverything_Nested `protobuf:"bytes,36,opt,name=nested_annotation,json=nestedAnnotation,proto3" json:"nested_annotation,omitempty"`
	Int64OverrideType int64                    `protobuf:"varint,37,opt,name=int64_override_type,json=int64OverrideType,proto3" json:"int64_override_type,omitempty"`
	// mark a field as required in Open API definition
	RequiredStringViaFieldBehaviorAnnotation string `` /* 190-byte string literal not displayed */
	// mark a field as readonly in Open API definition
	OutputOnlyStringViaFieldBehaviorAnnotation string  `` /* 198-byte string literal not displayed */
	OptionalStringValue                        *string `` /* 127-byte string literal not displayed */
	// contains filtered or unexported fields
}

Intentionally complicated message type to cover many features of Protobuf.

func (*ABitOfEverything) Descriptor deprecated

func (*ABitOfEverything) Descriptor() ([]byte, []int)

Deprecated: Use ABitOfEverything.ProtoReflect.Descriptor instead.

func (*ABitOfEverything) GetBoolValue

func (x *ABitOfEverything) GetBoolValue() bool

func (*ABitOfEverything) GetBytesValue

func (x *ABitOfEverything) GetBytesValue() []byte

func (*ABitOfEverything) GetDoubleValue

func (x *ABitOfEverything) GetDoubleValue() float64

func (*ABitOfEverything) GetEnumValue

func (x *ABitOfEverything) GetEnumValue() NumericEnum

func (*ABitOfEverything) GetEnumValueAnnotation

func (x *ABitOfEverything) GetEnumValueAnnotation() NumericEnum

func (*ABitOfEverything) GetFixed32Value

func (x *ABitOfEverything) GetFixed32Value() uint32

func (*ABitOfEverything) GetFixed64Value

func (x *ABitOfEverything) GetFixed64Value() uint64

func (*ABitOfEverything) GetFloatValue

func (x *ABitOfEverything) GetFloatValue() float32

func (*ABitOfEverything) GetInt32Value

func (x *ABitOfEverything) GetInt32Value() int32

func (*ABitOfEverything) GetInt64OverrideType

func (x *ABitOfEverything) GetInt64OverrideType() int64

func (*ABitOfEverything) GetInt64Value

func (x *ABitOfEverything) GetInt64Value() int64

func (*ABitOfEverything) GetMapValue

func (x *ABitOfEverything) GetMapValue() map[string]NumericEnum

func (*ABitOfEverything) GetMappedNestedValue

func (x *ABitOfEverything) GetMappedNestedValue() map[string]*ABitOfEverything_Nested

func (*ABitOfEverything) GetMappedStringValue

func (x *ABitOfEverything) GetMappedStringValue() map[string]string

func (*ABitOfEverything) GetNested

func (x *ABitOfEverything) GetNested() []*ABitOfEverything_Nested

func (*ABitOfEverything) GetNestedAnnotation

func (x *ABitOfEverything) GetNestedAnnotation() *ABitOfEverything_Nested

func (*ABitOfEverything) GetNestedPathEnumValue

func (x *ABitOfEverything) GetNestedPathEnumValue() pathenum.MessagePathEnum_NestedPathEnum

func (*ABitOfEverything) GetNonConventionalNameValue

func (x *ABitOfEverything) GetNonConventionalNameValue() string

func (*ABitOfEverything) GetOneofEmpty

func (x *ABitOfEverything) GetOneofEmpty() *emptypb.Empty

func (*ABitOfEverything) GetOneofString

func (x *ABitOfEverything) GetOneofString() string

func (*ABitOfEverything) GetOneofValue

func (m *ABitOfEverything) GetOneofValue() isABitOfEverything_OneofValue

func (*ABitOfEverything) GetOptionalStringValue

func (x *ABitOfEverything) GetOptionalStringValue() string

func (*ABitOfEverything) GetOutputOnlyStringViaFieldBehaviorAnnotation

func (x *ABitOfEverything) GetOutputOnlyStringViaFieldBehaviorAnnotation() string

func (*ABitOfEverything) GetPathEnumValue

func (x *ABitOfEverything) GetPathEnumValue() pathenum.PathEnum

func (*ABitOfEverything) GetRepeatedEnumAnnotation

func (x *ABitOfEverything) GetRepeatedEnumAnnotation() []NumericEnum

func (*ABitOfEverything) GetRepeatedEnumValue

func (x *ABitOfEverything) GetRepeatedEnumValue() []NumericEnum

func (*ABitOfEverything) GetRepeatedNestedAnnotation

func (x *ABitOfEverything) GetRepeatedNestedAnnotation() []*ABitOfEverything_Nested

func (*ABitOfEverything) GetRepeatedStringAnnotation

func (x *ABitOfEverything) GetRepeatedStringAnnotation() []string

func (*ABitOfEverything) GetRepeatedStringValue

func (x *ABitOfEverything) GetRepeatedStringValue() []string

func (*ABitOfEverything) GetRequiredStringViaFieldBehaviorAnnotation

func (x *ABitOfEverything) GetRequiredStringViaFieldBehaviorAnnotation() string

func (*ABitOfEverything) GetSfixed32Value

func (x *ABitOfEverything) GetSfixed32Value() int32

func (*ABitOfEverything) GetSfixed64Value

func (x *ABitOfEverything) GetSfixed64Value() int64

func (*ABitOfEverything) GetSingleNested

func (x *ABitOfEverything) GetSingleNested() *ABitOfEverything_Nested

func (*ABitOfEverything) GetSint32Value

func (x *ABitOfEverything) GetSint32Value() int32

func (*ABitOfEverything) GetSint64Value

func (x *ABitOfEverything) GetSint64Value() int64

func (*ABitOfEverything) GetStringValue

func (x *ABitOfEverything) GetStringValue() string

func (*ABitOfEverything) GetTimestampValue

func (x *ABitOfEverything) GetTimestampValue() *timestamppb.Timestamp

func (*ABitOfEverything) GetUint32Value

func (x *ABitOfEverything) GetUint32Value() uint32

func (*ABitOfEverything) GetUint64Value

func (x *ABitOfEverything) GetUint64Value() uint64

func (*ABitOfEverything) GetUuid

func (x *ABitOfEverything) GetUuid() string

func (*ABitOfEverything) ProtoMessage

func (*ABitOfEverything) ProtoMessage()

func (*ABitOfEverything) ProtoReflect

func (x *ABitOfEverything) ProtoReflect() protoreflect.Message

func (*ABitOfEverything) Reset

func (x *ABitOfEverything) Reset()

func (*ABitOfEverything) String

func (x *ABitOfEverything) String() string

type ABitOfEverythingRepeated

type ABitOfEverythingRepeated struct {

	// repeated values. they are comma-separated in path
	PathRepeatedFloatValue    []float32     `` /* 140-byte string literal not displayed */
	PathRepeatedDoubleValue   []float64     `` /* 143-byte string literal not displayed */
	PathRepeatedInt64Value    []int64       `` /* 139-byte string literal not displayed */
	PathRepeatedUint64Value   []uint64      `` /* 142-byte string literal not displayed */
	PathRepeatedInt32Value    []int32       `` /* 139-byte string literal not displayed */
	PathRepeatedFixed64Value  []uint64      `` /* 146-byte string literal not displayed */
	PathRepeatedFixed32Value  []uint32      `` /* 146-byte string literal not displayed */
	PathRepeatedBoolValue     []bool        `` /* 136-byte string literal not displayed */
	PathRepeatedStringValue   []string      `` /* 134-byte string literal not displayed */
	PathRepeatedBytesValue    [][]byte      `` /* 132-byte string literal not displayed */
	PathRepeatedUint32Value   []uint32      `` /* 143-byte string literal not displayed */
	PathRepeatedEnumValue     []NumericEnum `` /* 201-byte string literal not displayed */
	PathRepeatedSfixed32Value []int32       `` /* 150-byte string literal not displayed */
	PathRepeatedSfixed64Value []int64       `` /* 150-byte string literal not displayed */
	PathRepeatedSint32Value   []int32       `` /* 145-byte string literal not displayed */
	PathRepeatedSint64Value   []int64       `` /* 145-byte string literal not displayed */
	// contains filtered or unexported fields
}

ABitOfEverythingRepeated is used to validate repeated path parameter functionality

func (*ABitOfEverythingRepeated) Descriptor deprecated

func (*ABitOfEverythingRepeated) Descriptor() ([]byte, []int)

Deprecated: Use ABitOfEverythingRepeated.ProtoReflect.Descriptor instead.

func (*ABitOfEverythingRepeated) GetPathRepeatedBoolValue

func (x *ABitOfEverythingRepeated) GetPathRepeatedBoolValue() []bool

func (*ABitOfEverythingRepeated) GetPathRepeatedBytesValue

func (x *ABitOfEverythingRepeated) GetPathRepeatedBytesValue() [][]byte

func (*ABitOfEverythingRepeated) GetPathRepeatedDoubleValue

func (x *ABitOfEverythingRepeated) GetPathRepeatedDoubleValue() []float64

func (*ABitOfEverythingRepeated) GetPathRepeatedEnumValue

func (x *ABitOfEverythingRepeated) GetPathRepeatedEnumValue() []NumericEnum

func (*ABitOfEverythingRepeated) GetPathRepeatedFixed32Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedFixed32Value() []uint32

func (*ABitOfEverythingRepeated) GetPathRepeatedFixed64Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedFixed64Value() []uint64

func (*ABitOfEverythingRepeated) GetPathRepeatedFloatValue

func (x *ABitOfEverythingRepeated) GetPathRepeatedFloatValue() []float32

func (*ABitOfEverythingRepeated) GetPathRepeatedInt32Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedInt32Value() []int32

func (*ABitOfEverythingRepeated) GetPathRepeatedInt64Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedInt64Value() []int64

func (*ABitOfEverythingRepeated) GetPathRepeatedSfixed32Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedSfixed32Value() []int32

func (*ABitOfEverythingRepeated) GetPathRepeatedSfixed64Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedSfixed64Value() []int64

func (*ABitOfEverythingRepeated) GetPathRepeatedSint32Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedSint32Value() []int32

func (*ABitOfEverythingRepeated) GetPathRepeatedSint64Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedSint64Value() []int64

func (*ABitOfEverythingRepeated) GetPathRepeatedStringValue

func (x *ABitOfEverythingRepeated) GetPathRepeatedStringValue() []string

func (*ABitOfEverythingRepeated) GetPathRepeatedUint32Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedUint32Value() []uint32

func (*ABitOfEverythingRepeated) GetPathRepeatedUint64Value

func (x *ABitOfEverythingRepeated) GetPathRepeatedUint64Value() []uint64

func (*ABitOfEverythingRepeated) ProtoMessage

func (*ABitOfEverythingRepeated) ProtoMessage()

func (*ABitOfEverythingRepeated) ProtoReflect

func (x *ABitOfEverythingRepeated) ProtoReflect() protoreflect.Message

func (*ABitOfEverythingRepeated) Reset

func (x *ABitOfEverythingRepeated) Reset()

func (*ABitOfEverythingRepeated) String

func (x *ABitOfEverythingRepeated) String() string

type ABitOfEverythingServiceClient

type ABitOfEverythingServiceClient interface {
	// Create a new ABitOfEverything
	//
	// This API creates a new ABitOfEverything
	Create(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*ABitOfEverything, error)
	CreateBody(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*ABitOfEverything, error)
	// Create a book.
	CreateBook(ctx context.Context, in *CreateBookRequest, opts ...grpc.CallOption) (*Book, error)
	UpdateBook(ctx context.Context, in *UpdateBookRequest, opts ...grpc.CallOption) (*Book, error)
	Lookup(ctx context.Context, in *sub2.IdMessage, opts ...grpc.CallOption) (*ABitOfEverything, error)
	Update(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*emptypb.Empty, error)
	UpdateV2(ctx context.Context, in *UpdateV2Request, opts ...grpc.CallOption) (*emptypb.Empty, error)
	Delete(ctx context.Context, in *sub2.IdMessage, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetQuery(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetRepeatedQuery(ctx context.Context, in *ABitOfEverythingRepeated, opts ...grpc.CallOption) (*ABitOfEverythingRepeated, error)
	// Echo allows posting a StringMessage value.
	//
	// It also exposes multiple bindings.
	//
	// This makes it useful when validating that the OpenAPI v2 API
	// description exposes documentation correctly on all paths
	// defined as additional_bindings in the proto.
	Echo(ctx context.Context, in *sub.StringMessage, opts ...grpc.CallOption) (*sub.StringMessage, error)
	DeepPathEcho(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*ABitOfEverything, error)
	NoBindings(ctx context.Context, in *durationpb.Duration, opts ...grpc.CallOption) (*emptypb.Empty, error)
	Timeout(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ErrorWithDetails(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetMessageWithBody(ctx context.Context, in *MessageWithBody, opts ...grpc.CallOption) (*emptypb.Empty, error)
	PostWithEmptyBody(ctx context.Context, in *Body, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CheckGetQueryParams(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*ABitOfEverything, error)
	CheckNestedEnumGetQueryParams(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*ABitOfEverything, error)
	CheckPostQueryParams(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*ABitOfEverything, error)
	OverwriteResponseContentType(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*wrapperspb.StringValue, error)
	CheckExternalPathEnum(ctx context.Context, in *pathenum.MessageWithPathEnum, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CheckExternalNestedPathEnum(ctx context.Context, in *pathenum.MessageWithNestedPathEnum, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CheckStatus(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CheckStatusResponse, error)
}

ABitOfEverythingServiceClient is the client API for ABitOfEverythingService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type ABitOfEverythingServiceServer

type ABitOfEverythingServiceServer interface {
	// Create a new ABitOfEverything
	//
	// This API creates a new ABitOfEverything
	Create(context.Context, *ABitOfEverything) (*ABitOfEverything, error)
	CreateBody(context.Context, *ABitOfEverything) (*ABitOfEverything, error)
	// Create a book.
	CreateBook(context.Context, *CreateBookRequest) (*Book, error)
	UpdateBook(context.Context, *UpdateBookRequest) (*Book, error)
	Lookup(context.Context, *sub2.IdMessage) (*ABitOfEverything, error)
	Update(context.Context, *ABitOfEverything) (*emptypb.Empty, error)
	UpdateV2(context.Context, *UpdateV2Request) (*emptypb.Empty, error)
	Delete(context.Context, *sub2.IdMessage) (*emptypb.Empty, error)
	GetQuery(context.Context, *ABitOfEverything) (*emptypb.Empty, error)
	GetRepeatedQuery(context.Context, *ABitOfEverythingRepeated) (*ABitOfEverythingRepeated, error)
	// Echo allows posting a StringMessage value.
	//
	// It also exposes multiple bindings.
	//
	// This makes it useful when validating that the OpenAPI v2 API
	// description exposes documentation correctly on all paths
	// defined as additional_bindings in the proto.
	Echo(context.Context, *sub.StringMessage) (*sub.StringMessage, error)
	DeepPathEcho(context.Context, *ABitOfEverything) (*ABitOfEverything, error)
	NoBindings(context.Context, *durationpb.Duration) (*emptypb.Empty, error)
	Timeout(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
	ErrorWithDetails(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
	GetMessageWithBody(context.Context, *MessageWithBody) (*emptypb.Empty, error)
	PostWithEmptyBody(context.Context, *Body) (*emptypb.Empty, error)
	CheckGetQueryParams(context.Context, *ABitOfEverything) (*ABitOfEverything, error)
	CheckNestedEnumGetQueryParams(context.Context, *ABitOfEverything) (*ABitOfEverything, error)
	CheckPostQueryParams(context.Context, *ABitOfEverything) (*ABitOfEverything, error)
	OverwriteResponseContentType(context.Context, *emptypb.Empty) (*wrapperspb.StringValue, error)
	CheckExternalPathEnum(context.Context, *pathenum.MessageWithPathEnum) (*emptypb.Empty, error)
	CheckExternalNestedPathEnum(context.Context, *pathenum.MessageWithNestedPathEnum) (*emptypb.Empty, error)
	CheckStatus(context.Context, *emptypb.Empty) (*CheckStatusResponse, error)
}

ABitOfEverythingServiceServer is the server API for ABitOfEverythingService service. All implementations should embed UnimplementedABitOfEverythingServiceServer for forward compatibility

type ABitOfEverything_Nested

type ABitOfEverything_Nested struct {

	// name is nested field.
	Name   string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Amount uint32 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	// DeepEnum comment.
	Ok ABitOfEverything_Nested_DeepEnum `` /* 143-byte string literal not displayed */
	// contains filtered or unexported fields
}

Nested is nested type.

func (*ABitOfEverything_Nested) Descriptor deprecated

func (*ABitOfEverything_Nested) Descriptor() ([]byte, []int)

Deprecated: Use ABitOfEverything_Nested.ProtoReflect.Descriptor instead.

func (*ABitOfEverything_Nested) GetAmount

func (x *ABitOfEverything_Nested) GetAmount() uint32

func (*ABitOfEverything_Nested) GetName

func (x *ABitOfEverything_Nested) GetName() string

func (*ABitOfEverything_Nested) GetOk

func (*ABitOfEverything_Nested) ProtoMessage

func (*ABitOfEverything_Nested) ProtoMessage()

func (*ABitOfEverything_Nested) ProtoReflect

func (x *ABitOfEverything_Nested) ProtoReflect() protoreflect.Message

func (*ABitOfEverything_Nested) Reset

func (x *ABitOfEverything_Nested) Reset()

func (*ABitOfEverything_Nested) String

func (x *ABitOfEverything_Nested) String() string

type ABitOfEverything_Nested_DeepEnum

type ABitOfEverything_Nested_DeepEnum int32

DeepEnum is one or zero.

const (
	// FALSE is false.
	ABitOfEverything_Nested_FALSE ABitOfEverything_Nested_DeepEnum = 0
	// TRUE is true.
	ABitOfEverything_Nested_TRUE ABitOfEverything_Nested_DeepEnum = 1
)

func (ABitOfEverything_Nested_DeepEnum) Descriptor

func (ABitOfEverything_Nested_DeepEnum) Enum

func (ABitOfEverything_Nested_DeepEnum) EnumDescriptor deprecated

func (ABitOfEverything_Nested_DeepEnum) EnumDescriptor() ([]byte, []int)

Deprecated: Use ABitOfEverything_Nested_DeepEnum.Descriptor instead.

func (ABitOfEverything_Nested_DeepEnum) Number

func (ABitOfEverything_Nested_DeepEnum) String

func (ABitOfEverything_Nested_DeepEnum) Type

type ABitOfEverything_OneofEmpty

type ABitOfEverything_OneofEmpty struct {
	OneofEmpty *emptypb.Empty `protobuf:"bytes,20,opt,name=oneof_empty,json=oneofEmpty,proto3,oneof"`
}

type ABitOfEverything_OneofString

type ABitOfEverything_OneofString struct {
	OneofString string `protobuf:"bytes,21,opt,name=oneof_string,json=oneofString,proto3,oneof"`
}

type AnotherServiceWithNoBindingsClient

type AnotherServiceWithNoBindingsClient interface {
	NoBindings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

AnotherServiceWithNoBindingsClient is the client API for AnotherServiceWithNoBindings service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type AnotherServiceWithNoBindingsServer

type AnotherServiceWithNoBindingsServer interface {
	NoBindings(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
}

AnotherServiceWithNoBindingsServer is the server API for AnotherServiceWithNoBindings service. All implementations should embed UnimplementedAnotherServiceWithNoBindingsServer for forward compatibility

type Body

type Body struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*Body) Descriptor deprecated

func (*Body) Descriptor() ([]byte, []int)

Deprecated: Use Body.ProtoReflect.Descriptor instead.

func (*Body) GetName

func (x *Body) GetName() string

func (*Body) ProtoMessage

func (*Body) ProtoMessage()

func (*Body) ProtoReflect

func (x *Body) ProtoReflect() protoreflect.Message

func (*Body) Reset

func (x *Body) Reset()

func (*Body) String

func (x *Body) String() string

type Book

type Book struct {

	// The resource name of the book.
	//
	// Format: `publishers/{publisher}/books/{book}`
	//
	// Example: `publishers/1257894000000000000/books/my-book`
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Output only. The book's ID.
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	// Output only. Creation time of the book.
	CreateTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	// contains filtered or unexported fields
}

An example resource type from AIP-123 used to test the behavior described in the CreateBookRequest message.

See: https://google.aip.dev/123

func (*Book) Descriptor deprecated

func (*Book) Descriptor() ([]byte, []int)

Deprecated: Use Book.ProtoReflect.Descriptor instead.

func (*Book) GetCreateTime

func (x *Book) GetCreateTime() *timestamppb.Timestamp

func (*Book) GetId

func (x *Book) GetId() string

func (*Book) GetName

func (x *Book) GetName() string

func (*Book) ProtoMessage

func (*Book) ProtoMessage()

func (*Book) ProtoReflect

func (x *Book) ProtoReflect() protoreflect.Message

func (*Book) Reset

func (x *Book) Reset()

func (*Book) String

func (x *Book) String() string

type CamelCaseServiceNameClient

type CamelCaseServiceNameClient interface {
	Empty(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

CamelCaseServiceNameClient is the client API for CamelCaseServiceName service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type CamelCaseServiceNameServer

type CamelCaseServiceNameServer interface {
	Empty(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
}

CamelCaseServiceNameServer is the server API for CamelCaseServiceName service. All implementations should embed UnimplementedCamelCaseServiceNameServer for forward compatibility

type CheckStatusResponse

type CheckStatusResponse struct {
	Status *status.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

func (*CheckStatusResponse) Descriptor deprecated

func (*CheckStatusResponse) Descriptor() ([]byte, []int)

Deprecated: Use CheckStatusResponse.ProtoReflect.Descriptor instead.

func (*CheckStatusResponse) GetStatus

func (x *CheckStatusResponse) GetStatus() *status.Status

func (*CheckStatusResponse) ProtoMessage

func (*CheckStatusResponse) ProtoMessage()

func (*CheckStatusResponse) ProtoReflect

func (x *CheckStatusResponse) ProtoReflect() protoreflect.Message

func (*CheckStatusResponse) Reset

func (x *CheckStatusResponse) Reset()

func (*CheckStatusResponse) String

func (x *CheckStatusResponse) String() string

type CreateBookRequest

type CreateBookRequest struct {

	// The publisher in which to create the book.
	//
	// Format: `publishers/{publisher}`
	//
	// Example: `publishers/1257894000000000000`
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// The book to create.
	Book *Book `protobuf:"bytes,2,opt,name=book,proto3" json:"book,omitempty"`
	// The ID to use for the book.
	//
	// This must start with an alphanumeric character.
	BookId string `protobuf:"bytes,3,opt,name=book_id,json=bookId,proto3" json:"book_id,omitempty"`
	// contains filtered or unexported fields
}

A standard Create message from AIP-133 with a user-specified ID. The user-specified ID (the `book_id` field in this example) must become a query parameter in the OpenAPI spec.

See: https://google.aip.dev/133#user-specified-ids

func (*CreateBookRequest) Descriptor deprecated

func (*CreateBookRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateBookRequest.ProtoReflect.Descriptor instead.

func (*CreateBookRequest) GetBook

func (x *CreateBookRequest) GetBook() *Book

func (*CreateBookRequest) GetBookId

func (x *CreateBookRequest) GetBookId() string

func (*CreateBookRequest) GetParent

func (x *CreateBookRequest) GetParent() string

func (*CreateBookRequest) ProtoMessage

func (*CreateBookRequest) ProtoMessage()

func (*CreateBookRequest) ProtoReflect

func (x *CreateBookRequest) ProtoReflect() protoreflect.Message

func (*CreateBookRequest) Reset

func (x *CreateBookRequest) Reset()

func (*CreateBookRequest) String

func (x *CreateBookRequest) String() string

type DynamicMessage

type DynamicMessage struct {
	StructField *structpb.Struct `protobuf:"bytes,1,opt,name=struct_field,json=structField,proto3" json:"struct_field,omitempty"`
	ValueField  *structpb.Value  `protobuf:"bytes,2,opt,name=value_field,json=valueField,proto3" json:"value_field,omitempty"`
	// contains filtered or unexported fields
}

DynamicMessage represents a message which can have its structure built dynamically using Struct and Values.

func (*DynamicMessage) Descriptor deprecated

func (*DynamicMessage) Descriptor() ([]byte, []int)

Deprecated: Use DynamicMessage.ProtoReflect.Descriptor instead.

func (*DynamicMessage) GetStructField

func (x *DynamicMessage) GetStructField() *structpb.Struct

func (*DynamicMessage) GetValueField

func (x *DynamicMessage) GetValueField() *structpb.Value

func (*DynamicMessage) ProtoMessage

func (*DynamicMessage) ProtoMessage()

func (*DynamicMessage) ProtoReflect

func (x *DynamicMessage) ProtoReflect() protoreflect.Message

func (*DynamicMessage) Reset

func (x *DynamicMessage) Reset()

func (*DynamicMessage) String

func (x *DynamicMessage) String() string

type DynamicMessageUpdate

type DynamicMessageUpdate struct {
	Body       *DynamicMessage        `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// contains filtered or unexported fields
}

func (*DynamicMessageUpdate) Descriptor deprecated

func (*DynamicMessageUpdate) Descriptor() ([]byte, []int)

Deprecated: Use DynamicMessageUpdate.ProtoReflect.Descriptor instead.

func (*DynamicMessageUpdate) GetBody

func (x *DynamicMessageUpdate) GetBody() *DynamicMessage

func (*DynamicMessageUpdate) GetUpdateMask

func (x *DynamicMessageUpdate) GetUpdateMask() *fieldmaskpb.FieldMask

func (*DynamicMessageUpdate) ProtoMessage

func (*DynamicMessageUpdate) ProtoMessage()

func (*DynamicMessageUpdate) ProtoReflect

func (x *DynamicMessageUpdate) ProtoReflect() protoreflect.Message

func (*DynamicMessageUpdate) Reset

func (x *DynamicMessageUpdate) Reset()

func (*DynamicMessageUpdate) String

func (x *DynamicMessageUpdate) String() string

type EchoServiceClient

type EchoServiceClient interface {
	// Echo method receives a simple message and returns it.
	//
	// The message posted as the id parameter will also be
	// returned.
	Echo(ctx context.Context, in *SimpleMessage, opts ...grpc.CallOption) (*SimpleMessage, error)
	// EchoBody method receives a simple message and returns it.
	EchoBody(ctx context.Context, in *SimpleMessage, opts ...grpc.CallOption) (*SimpleMessage, error)
	// EchoDelete method receives a simple message and returns it.
	EchoDelete(ctx context.Context, in *SimpleMessage, opts ...grpc.CallOption) (*SimpleMessage, error)
	// EchoPatch method receives a NonStandardUpdateRequest and returns it.
	EchoPatch(ctx context.Context, in *DynamicMessageUpdate, opts ...grpc.CallOption) (*DynamicMessageUpdate, error)
	// EchoUnauthorized method receives a simple message and returns it. It must
	// always return a google.rpc.Code of `UNAUTHENTICATED` and a HTTP Status code
	// of 401.
	EchoUnauthorized(ctx context.Context, in *SimpleMessage, opts ...grpc.CallOption) (*SimpleMessage, error)
}

EchoServiceClient is the client API for EchoService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type EchoServiceServer

type EchoServiceServer interface {
	// Echo method receives a simple message and returns it.
	//
	// The message posted as the id parameter will also be
	// returned.
	Echo(context.Context, *SimpleMessage) (*SimpleMessage, error)
	// EchoBody method receives a simple message and returns it.
	EchoBody(context.Context, *SimpleMessage) (*SimpleMessage, error)
	// EchoDelete method receives a simple message and returns it.
	EchoDelete(context.Context, *SimpleMessage) (*SimpleMessage, error)
	// EchoPatch method receives a NonStandardUpdateRequest and returns it.
	EchoPatch(context.Context, *DynamicMessageUpdate) (*DynamicMessageUpdate, error)
	// EchoUnauthorized method receives a simple message and returns it. It must
	// always return a google.rpc.Code of `UNAUTHENTICATED` and a HTTP Status code
	// of 401.
	EchoUnauthorized(context.Context, *SimpleMessage) (*SimpleMessage, error)
}

EchoServiceServer is the server API for EchoService service. All implementations should embed UnimplementedEchoServiceServer for forward compatibility

type Embedded

type Embedded struct {

	// Types that are assignable to Mark:
	//	*Embedded_Progress
	//	*Embedded_Note
	Mark isEmbedded_Mark `protobuf_oneof:"mark"`
	// contains filtered or unexported fields
}

Embedded represents a message embedded in SimpleMessage.

func (*Embedded) Descriptor deprecated

func (*Embedded) Descriptor() ([]byte, []int)

Deprecated: Use Embedded.ProtoReflect.Descriptor instead.

func (*Embedded) GetMark

func (m *Embedded) GetMark() isEmbedded_Mark

func (*Embedded) GetNote

func (x *Embedded) GetNote() string

func (*Embedded) GetProgress

func (x *Embedded) GetProgress() int64

func (*Embedded) ProtoMessage

func (*Embedded) ProtoMessage()

func (*Embedded) ProtoReflect

func (x *Embedded) ProtoReflect() protoreflect.Message

func (*Embedded) Reset

func (x *Embedded) Reset()

func (*Embedded) String

func (x *Embedded) String() string

type Embedded_Note

type Embedded_Note struct {
	Note string `protobuf:"bytes,2,opt,name=note,proto3,oneof"`
}

type Embedded_Progress

type Embedded_Progress struct {
	Progress int64 `protobuf:"varint,1,opt,name=progress,proto3,oneof"`
}

type EmptyProto

type EmptyProto struct {
	// contains filtered or unexported fields
}

func (*EmptyProto) Descriptor deprecated

func (*EmptyProto) Descriptor() ([]byte, []int)

Deprecated: Use EmptyProto.ProtoReflect.Descriptor instead.

func (*EmptyProto) ProtoMessage

func (*EmptyProto) ProtoMessage()

func (*EmptyProto) ProtoReflect

func (x *EmptyProto) ProtoReflect() protoreflect.Message

func (*EmptyProto) Reset

func (x *EmptyProto) Reset()

func (*EmptyProto) String

func (x *EmptyProto) String() string

type ErrorObject

type ErrorObject struct {
	Code    int32  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

func (*ErrorObject) Descriptor deprecated

func (*ErrorObject) Descriptor() ([]byte, []int)

Deprecated: Use ErrorObject.ProtoReflect.Descriptor instead.

func (*ErrorObject) GetCode

func (x *ErrorObject) GetCode() int32

func (*ErrorObject) GetMessage

func (x *ErrorObject) GetMessage() string

func (*ErrorObject) ProtoMessage

func (*ErrorObject) ProtoMessage()

func (*ErrorObject) ProtoReflect

func (x *ErrorObject) ProtoReflect() protoreflect.Message

func (*ErrorObject) Reset

func (x *ErrorObject) Reset()

func (*ErrorObject) String

func (x *ErrorObject) String() string

type ErrorResponse

type ErrorResponse struct {
	CorrelationId string       `protobuf:"bytes,1,opt,name=correlationId,proto3" json:"correlationId,omitempty"`
	Error         *ErrorObject `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	// contains filtered or unexported fields
}

func (*ErrorResponse) Descriptor deprecated

func (*ErrorResponse) Descriptor() ([]byte, []int)

Deprecated: Use ErrorResponse.ProtoReflect.Descriptor instead.

func (*ErrorResponse) GetCorrelationId

func (x *ErrorResponse) GetCorrelationId() string

func (*ErrorResponse) GetError

func (x *ErrorResponse) GetError() *ErrorObject

func (*ErrorResponse) ProtoMessage

func (*ErrorResponse) ProtoMessage()

func (*ErrorResponse) ProtoReflect

func (x *ErrorResponse) ProtoReflect() protoreflect.Message

func (*ErrorResponse) Reset

func (x *ErrorResponse) Reset()

func (*ErrorResponse) String

func (x *ErrorResponse) String() string

type FlowCombinationClient

type FlowCombinationClient interface {
	RpcEmptyRpc(ctx context.Context, in *EmptyProto, opts ...grpc.CallOption) (*EmptyProto, error)
	RpcEmptyStream(ctx context.Context, in *EmptyProto, opts ...grpc.CallOption) (FlowCombination_RpcEmptyStreamClient, error)
	StreamEmptyRpc(ctx context.Context, opts ...grpc.CallOption) (FlowCombination_StreamEmptyRpcClient, error)
	StreamEmptyStream(ctx context.Context, opts ...grpc.CallOption) (FlowCombination_StreamEmptyStreamClient, error)
	RpcBodyRpc(ctx context.Context, in *NonEmptyProto, opts ...grpc.CallOption) (*EmptyProto, error)
	RpcPathSingleNestedRpc(ctx context.Context, in *SingleNestedProto, opts ...grpc.CallOption) (*EmptyProto, error)
	RpcPathNestedRpc(ctx context.Context, in *NestedProto, opts ...grpc.CallOption) (*EmptyProto, error)
	RpcBodyStream(ctx context.Context, in *NonEmptyProto, opts ...grpc.CallOption) (FlowCombination_RpcBodyStreamClient, error)
	RpcPathSingleNestedStream(ctx context.Context, in *SingleNestedProto, opts ...grpc.CallOption) (FlowCombination_RpcPathSingleNestedStreamClient, error)
	RpcPathNestedStream(ctx context.Context, in *NestedProto, opts ...grpc.CallOption) (FlowCombination_RpcPathNestedStreamClient, error)
}

FlowCombinationClient is the client API for FlowCombination service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type FlowCombinationServer

FlowCombinationServer is the server API for FlowCombination service. All implementations should embed UnimplementedFlowCombinationServer for forward compatibility

type FlowCombination_RpcBodyStreamClient

type FlowCombination_RpcBodyStreamClient interface {
	Recv() (*EmptyProto, error)
	grpc.ClientStream
}

type FlowCombination_RpcBodyStreamServer

type FlowCombination_RpcBodyStreamServer interface {
	Send(*EmptyProto) error
	grpc.ServerStream
}

type FlowCombination_RpcEmptyStreamClient

type FlowCombination_RpcEmptyStreamClient interface {
	Recv() (*EmptyProto, error)
	grpc.ClientStream
}

type FlowCombination_RpcEmptyStreamServer

type FlowCombination_RpcEmptyStreamServer interface {
	Send(*EmptyProto) error
	grpc.ServerStream
}

type FlowCombination_RpcPathNestedStreamClient

type FlowCombination_RpcPathNestedStreamClient interface {
	Recv() (*EmptyProto, error)
	grpc.ClientStream
}

type FlowCombination_RpcPathNestedStreamServer

type FlowCombination_RpcPathNestedStreamServer interface {
	Send(*EmptyProto) error
	grpc.ServerStream
}

type FlowCombination_RpcPathSingleNestedStreamClient

type FlowCombination_RpcPathSingleNestedStreamClient interface {
	Recv() (*EmptyProto, error)
	grpc.ClientStream
}

type FlowCombination_RpcPathSingleNestedStreamServer

type FlowCombination_RpcPathSingleNestedStreamServer interface {
	Send(*EmptyProto) error
	grpc.ServerStream
}

type FlowCombination_StreamEmptyRpcClient

type FlowCombination_StreamEmptyRpcClient interface {
	Send(*EmptyProto) error
	CloseAndRecv() (*EmptyProto, error)
	grpc.ClientStream
}

type FlowCombination_StreamEmptyRpcServer

type FlowCombination_StreamEmptyRpcServer interface {
	SendAndClose(*EmptyProto) error
	Recv() (*EmptyProto, error)
	grpc.ServerStream
}

type FlowCombination_StreamEmptyStreamClient

type FlowCombination_StreamEmptyStreamClient interface {
	Send(*EmptyProto) error
	Recv() (*EmptyProto, error)
	grpc.ClientStream
}

type FlowCombination_StreamEmptyStreamServer

type FlowCombination_StreamEmptyStreamServer interface {
	Send(*EmptyProto) error
	Recv() (*EmptyProto, error)
	grpc.ServerStream
}

type GenerateUnboundMethodsEchoServiceClient

type GenerateUnboundMethodsEchoServiceClient interface {
	// Echo method receives a simple message and returns it.
	//
	// The message posted as the id parameter will also be
	// returned.
	Echo(ctx context.Context, in *GenerateUnboundMethodsSimpleMessage, opts ...grpc.CallOption) (*GenerateUnboundMethodsSimpleMessage, error)
	// EchoBody method receives a simple message and returns it.
	EchoBody(ctx context.Context, in *GenerateUnboundMethodsSimpleMessage, opts ...grpc.CallOption) (*GenerateUnboundMethodsSimpleMessage, error)
	// EchoDelete method receives a simple message and returns it.
	EchoDelete(ctx context.Context, in *GenerateUnboundMethodsSimpleMessage, opts ...grpc.CallOption) (*GenerateUnboundMethodsSimpleMessage, error)
}

GenerateUnboundMethodsEchoServiceClient is the client API for GenerateUnboundMethodsEchoService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type GenerateUnboundMethodsEchoServiceServer

type GenerateUnboundMethodsEchoServiceServer interface {
	// Echo method receives a simple message and returns it.
	//
	// The message posted as the id parameter will also be
	// returned.
	Echo(context.Context, *GenerateUnboundMethodsSimpleMessage) (*GenerateUnboundMethodsSimpleMessage, error)
	// EchoBody method receives a simple message and returns it.
	EchoBody(context.Context, *GenerateUnboundMethodsSimpleMessage) (*GenerateUnboundMethodsSimpleMessage, error)
	// EchoDelete method receives a simple message and returns it.
	EchoDelete(context.Context, *GenerateUnboundMethodsSimpleMessage) (*GenerateUnboundMethodsSimpleMessage, error)
}

GenerateUnboundMethodsEchoServiceServer is the server API for GenerateUnboundMethodsEchoService service. All implementations should embed UnimplementedGenerateUnboundMethodsEchoServiceServer for forward compatibility

type GenerateUnboundMethodsSimpleMessage

type GenerateUnboundMethodsSimpleMessage struct {

	// Id represents the message identifier.
	Id       string               `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Num      int64                `protobuf:"varint,2,opt,name=num,proto3" json:"num,omitempty"`
	Duration *durationpb.Duration `protobuf:"bytes,3,opt,name=duration,proto3" json:"duration,omitempty"`
	// contains filtered or unexported fields
}

GenerateUnboundMethodsSimpleMessage represents a simple message sent to the unannotated GenerateUnboundMethodsEchoService service.

func (*GenerateUnboundMethodsSimpleMessage) Descriptor deprecated

func (*GenerateUnboundMethodsSimpleMessage) Descriptor() ([]byte, []int)

Deprecated: Use GenerateUnboundMethodsSimpleMessage.ProtoReflect.Descriptor instead.

func (*GenerateUnboundMethodsSimpleMessage) GetDuration

func (*GenerateUnboundMethodsSimpleMessage) GetId

func (*GenerateUnboundMethodsSimpleMessage) GetNum

func (*GenerateUnboundMethodsSimpleMessage) ProtoMessage

func (*GenerateUnboundMethodsSimpleMessage) ProtoMessage()

func (*GenerateUnboundMethodsSimpleMessage) ProtoReflect

func (*GenerateUnboundMethodsSimpleMessage) Reset

func (*GenerateUnboundMethodsSimpleMessage) String

type InMessageA

type InMessageA struct {

	// Here is the explanation about InMessageA.values
	Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

InMessageA represents a message to ServiceA and ServiceC.

func (*InMessageA) Descriptor deprecated

func (*InMessageA) Descriptor() ([]byte, []int)

Deprecated: Use InMessageA.ProtoReflect.Descriptor instead.

func (*InMessageA) GetValues

func (x *InMessageA) GetValues() []string

func (*InMessageA) ProtoMessage

func (*InMessageA) ProtoMessage()

func (*InMessageA) ProtoReflect

func (x *InMessageA) ProtoReflect() protoreflect.Message

func (*InMessageA) Reset

func (x *InMessageA) Reset()

func (*InMessageA) String

func (x *InMessageA) String() string

type InMessageB

type InMessageB struct {

	// Here is the explanation about InMessageB.values
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

InMessageB represents a message to ServiceB.

func (*InMessageB) Descriptor deprecated

func (*InMessageB) Descriptor() ([]byte, []int)

Deprecated: Use InMessageB.ProtoReflect.Descriptor instead.

func (*InMessageB) GetValue

func (x *InMessageB) GetValue() string

func (*InMessageB) ProtoMessage

func (*InMessageB) ProtoMessage()

func (*InMessageB) ProtoReflect

func (x *InMessageB) ProtoReflect() protoreflect.Message

func (*InMessageB) Reset

func (x *InMessageB) Reset()

func (*InMessageB) String

func (x *InMessageB) String() string

type LoginReply

type LoginReply struct {
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	// Whether you have access or not
	Access bool `protobuf:"varint,2,opt,name=access,proto3" json:"access,omitempty"`
	// contains filtered or unexported fields
}

func (*LoginReply) Descriptor deprecated

func (*LoginReply) Descriptor() ([]byte, []int)

Deprecated: Use LoginReply.ProtoReflect.Descriptor instead.

func (*LoginReply) GetAccess

func (x *LoginReply) GetAccess() bool

func (*LoginReply) GetMessage

func (x *LoginReply) GetMessage() string

func (*LoginReply) ProtoMessage

func (*LoginReply) ProtoMessage()

func (*LoginReply) ProtoReflect

func (x *LoginReply) ProtoReflect() protoreflect.Message

func (*LoginReply) Reset

func (x *LoginReply) Reset()

func (*LoginReply) String

func (x *LoginReply) String() string

type LoginRequest

type LoginRequest struct {

	// The entered username
	Username string `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	// The entered password
	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	// contains filtered or unexported fields
}

func (*LoginRequest) Descriptor deprecated

func (*LoginRequest) Descriptor() ([]byte, []int)

Deprecated: Use LoginRequest.ProtoReflect.Descriptor instead.

func (*LoginRequest) GetPassword

func (x *LoginRequest) GetPassword() string

func (*LoginRequest) GetUsername

func (x *LoginRequest) GetUsername() string

func (*LoginRequest) ProtoMessage

func (*LoginRequest) ProtoMessage()

func (*LoginRequest) ProtoReflect

func (x *LoginRequest) ProtoReflect() protoreflect.Message

func (*LoginRequest) Reset

func (x *LoginRequest) Reset()

func (*LoginRequest) String

func (x *LoginRequest) String() string

type LoginServiceClient

type LoginServiceClient interface {
	// Login
	//
	// {{.MethodDescriptorProto.Name}} is a call with the method(s) {{$first := true}}{{range .Bindings}}{{if $first}}{{$first = false}}{{else}}, {{end}}{{.HTTPMethod}}{{end}} within the "{{.Service.Name}}" service.
	// It takes in "{{.RequestType.Name}}" and returns a "{{.ResponseType.Name}}".
	//
	// ## {{.RequestType.Name}}
	// | Field ID    | Name      | Type                                                       | Description                  |
	// | ----------- | --------- | ---------------------------------------------------------  | ---------------------------- | {{range .RequestType.Fields}}
	// | {{.Number}} | {{.Name}} | {{if eq .Label.String "LABEL_REPEATED"}}[]{{end}}{{.Type}} | {{fieldcomments .Message .}} | {{end}}
	//
	// ## {{.ResponseType.Name}}
	// | Field ID    | Name      | Type                                                       | Description                  |
	// | ----------- | --------- | ---------------------------------------------------------- | ---------------------------- | {{range .ResponseType.Fields}}
	// | {{.Number}} | {{.Name}} | {{if eq .Label.String "LABEL_REPEATED"}}[]{{end}}{{.Type}} | {{fieldcomments .Message .}} | {{end}}
	Login(ctx context.Context, in *LoginRequest, opts ...grpc.CallOption) (*LoginReply, error)
	// Logout
	//
	// {{.MethodDescriptorProto.Name}} is a call with the method(s) {{$first := true}}{{range .Bindings}}{{if $first}}{{$first = false}}{{else}}, {{end}}{{.HTTPMethod}}{{end}} within the "{{.Service.Name}}" service.
	// It takes in "{{.RequestType.Name}}" and returns a "{{.ResponseType.Name}}".
	//
	// ## {{.RequestType.Name}}
	// | Field ID    | Name      | Type                                                       | Description                  |
	// | ----------- | --------- | ---------------------------------------------------------  | ---------------------------- | {{range .RequestType.Fields}}
	// | {{.Number}} | {{.Name}} | {{if eq .Label.String "LABEL_REPEATED"}}[]{{end}}{{.Type}} | {{fieldcomments .Message .}} | {{end}}
	//
	// ## {{.ResponseType.Name}}
	// | Field ID    | Name      | Type                                                       | Description                  |
	// | ----------- | --------- | ---------------------------------------------------------- | ---------------------------- | {{range .ResponseType.Fields}}
	// | {{.Number}} | {{.Name}} | {{if eq .Label.String "LABEL_REPEATED"}}[]{{end}}{{.Type}} | {{fieldcomments .Message .}} | {{end}}
	Logout(ctx context.Context, in *LogoutRequest, opts ...grpc.CallOption) (*LogoutReply, error)
}

LoginServiceClient is the client API for LoginService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type LoginServiceServer

type LoginServiceServer interface {
	// Login
	//
	// {{.MethodDescriptorProto.Name}} is a call with the method(s) {{$first := true}}{{range .Bindings}}{{if $first}}{{$first = false}}{{else}}, {{end}}{{.HTTPMethod}}{{end}} within the "{{.Service.Name}}" service.
	// It takes in "{{.RequestType.Name}}" and returns a "{{.ResponseType.Name}}".
	//
	// ## {{.RequestType.Name}}
	// | Field ID    | Name      | Type                                                       | Description                  |
	// | ----------- | --------- | ---------------------------------------------------------  | ---------------------------- | {{range .RequestType.Fields}}
	// | {{.Number}} | {{.Name}} | {{if eq .Label.String "LABEL_REPEATED"}}[]{{end}}{{.Type}} | {{fieldcomments .Message .}} | {{end}}
	//
	// ## {{.ResponseType.Name}}
	// | Field ID    | Name      | Type                                                       | Description                  |
	// | ----------- | --------- | ---------------------------------------------------------- | ---------------------------- | {{range .ResponseType.Fields}}
	// | {{.Number}} | {{.Name}} | {{if eq .Label.String "LABEL_REPEATED"}}[]{{end}}{{.Type}} | {{fieldcomments .Message .}} | {{end}}
	Login(context.Context, *LoginRequest) (*LoginReply, error)
	// Logout
	//
	// {{.MethodDescriptorProto.Name}} is a call with the method(s) {{$first := true}}{{range .Bindings}}{{if $first}}{{$first = false}}{{else}}, {{end}}{{.HTTPMethod}}{{end}} within the "{{.Service.Name}}" service.
	// It takes in "{{.RequestType.Name}}" and returns a "{{.ResponseType.Name}}".
	//
	// ## {{.RequestType.Name}}
	// | Field ID    | Name      | Type                                                       | Description                  |
	// | ----------- | --------- | ---------------------------------------------------------  | ---------------------------- | {{range .RequestType.Fields}}
	// | {{.Number}} | {{.Name}} | {{if eq .Label.String "LABEL_REPEATED"}}[]{{end}}{{.Type}} | {{fieldcomments .Message .}} | {{end}}
	//
	// ## {{.ResponseType.Name}}
	// | Field ID    | Name      | Type                                                       | Description                  |
	// | ----------- | --------- | ---------------------------------------------------------- | ---------------------------- | {{range .ResponseType.Fields}}
	// | {{.Number}} | {{.Name}} | {{if eq .Label.String "LABEL_REPEATED"}}[]{{end}}{{.Type}} | {{fieldcomments .Message .}} | {{end}}
	Logout(context.Context, *LogoutRequest) (*LogoutReply, error)
}

LoginServiceServer is the server API for LoginService service. All implementations should embed UnimplementedLoginServiceServer for forward compatibility

type LogoutReply

type LogoutReply struct {

	// Message that tells you whether your
	// logout was succesful or not
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

func (*LogoutReply) Descriptor deprecated

func (*LogoutReply) Descriptor() ([]byte, []int)

Deprecated: Use LogoutReply.ProtoReflect.Descriptor instead.

func (*LogoutReply) GetMessage

func (x *LogoutReply) GetMessage() string

func (*LogoutReply) ProtoMessage

func (*LogoutReply) ProtoMessage()

func (*LogoutReply) ProtoReflect

func (x *LogoutReply) ProtoReflect() protoreflect.Message

func (*LogoutReply) Reset

func (x *LogoutReply) Reset()

func (*LogoutReply) String

func (x *LogoutReply) String() string

type LogoutRequest

type LogoutRequest struct {

	// The time the logout was registered
	Timeoflogout string `protobuf:"bytes,1,opt,name=timeoflogout,proto3" json:"timeoflogout,omitempty"`
	// This is the title
	//
	// This is the "Description" of field test
	// you can use as many newlines as you want
	//
	//
	// it will still format the same in the table
	Test int32 `protobuf:"varint,2,opt,name=test,proto3" json:"test,omitempty"`
	// This is an array
	//
	// It displays that using [] infront of the type
	Stringarray []string `protobuf:"bytes,3,rep,name=stringarray,proto3" json:"stringarray,omitempty"`
	// contains filtered or unexported fields
}

func (*LogoutRequest) Descriptor deprecated

func (*LogoutRequest) Descriptor() ([]byte, []int)

Deprecated: Use LogoutRequest.ProtoReflect.Descriptor instead.

func (*LogoutRequest) GetStringarray

func (x *LogoutRequest) GetStringarray() []string

func (*LogoutRequest) GetTest

func (x *LogoutRequest) GetTest() int32

func (*LogoutRequest) GetTimeoflogout

func (x *LogoutRequest) GetTimeoflogout() string

func (*LogoutRequest) ProtoMessage

func (*LogoutRequest) ProtoMessage()

func (*LogoutRequest) ProtoReflect

func (x *LogoutRequest) ProtoReflect() protoreflect.Message

func (*LogoutRequest) Reset

func (x *LogoutRequest) Reset()

func (*LogoutRequest) String

func (x *LogoutRequest) String() string

type MessageWithBody

type MessageWithBody struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Data *Body  `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

func (*MessageWithBody) Descriptor deprecated

func (*MessageWithBody) Descriptor() ([]byte, []int)

Deprecated: Use MessageWithBody.ProtoReflect.Descriptor instead.

func (*MessageWithBody) GetData

func (x *MessageWithBody) GetData() *Body

func (*MessageWithBody) GetId

func (x *MessageWithBody) GetId() string

func (*MessageWithBody) ProtoMessage

func (*MessageWithBody) ProtoMessage()

func (*MessageWithBody) ProtoReflect

func (x *MessageWithBody) ProtoReflect() protoreflect.Message

func (*MessageWithBody) Reset

func (x *MessageWithBody) Reset()

func (*MessageWithBody) String

func (x *MessageWithBody) String() string

type NestedProto

type NestedProto struct {
	A *UnaryProto `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"`
	B string      `protobuf:"bytes,2,opt,name=b,proto3" json:"b,omitempty"`
	C string      `protobuf:"bytes,3,opt,name=c,proto3" json:"c,omitempty"`
	// contains filtered or unexported fields
}

func (*NestedProto) Descriptor deprecated

func (*NestedProto) Descriptor() ([]byte, []int)

Deprecated: Use NestedProto.ProtoReflect.Descriptor instead.

func (*NestedProto) GetA

func (x *NestedProto) GetA() *UnaryProto

func (*NestedProto) GetB

func (x *NestedProto) GetB() string

func (*NestedProto) GetC

func (x *NestedProto) GetC() string

func (*NestedProto) ProtoMessage

func (*NestedProto) ProtoMessage()

func (*NestedProto) ProtoReflect

func (x *NestedProto) ProtoReflect() protoreflect.Message

func (*NestedProto) Reset

func (x *NestedProto) Reset()

func (*NestedProto) String

func (x *NestedProto) String() string

type NonEmptyProto

type NonEmptyProto struct {
	A string `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"`
	B string `protobuf:"bytes,2,opt,name=b,proto3" json:"b,omitempty"`
	C string `protobuf:"bytes,3,opt,name=c,proto3" json:"c,omitempty"`
	// contains filtered or unexported fields
}

func (*NonEmptyProto) Descriptor deprecated

func (*NonEmptyProto) Descriptor() ([]byte, []int)

Deprecated: Use NonEmptyProto.ProtoReflect.Descriptor instead.

func (*NonEmptyProto) GetA

func (x *NonEmptyProto) GetA() string

func (*NonEmptyProto) GetB

func (x *NonEmptyProto) GetB() string

func (*NonEmptyProto) GetC

func (x *NonEmptyProto) GetC() string

func (*NonEmptyProto) ProtoMessage

func (*NonEmptyProto) ProtoMessage()

func (*NonEmptyProto) ProtoReflect

func (x *NonEmptyProto) ProtoReflect() protoreflect.Message

func (*NonEmptyProto) Reset

func (x *NonEmptyProto) Reset()

func (*NonEmptyProto) String

func (x *NonEmptyProto) String() string

type NonStandardMessage

type NonStandardMessage struct {

	// Id represents the message identifier.
	Id        string                    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Num       int64                     `protobuf:"varint,2,opt,name=Num,proto3" json:"Num,omitempty"`
	LineNum   int64                     `protobuf:"varint,3,opt,name=line_num,json=lineNum,proto3" json:"line_num,omitempty"`
	LangIdent string                    `protobuf:"bytes,4,opt,name=langIdent,proto3" json:"langIdent,omitempty"`
	STATUS    string                    `protobuf:"bytes,5,opt,name=STATUS,proto3" json:"STATUS,omitempty"`
	En_GB     int64                     `protobuf:"varint,6,opt,name=en_GB,json=enGB,proto3" json:"en_GB,omitempty"`
	No        string                    `protobuf:"bytes,7,opt,name=no,proto3" json:"no,omitempty"`
	Thing     *NonStandardMessage_Thing `protobuf:"bytes,8,opt,name=thing,proto3" json:"thing,omitempty"`
	// contains filtered or unexported fields
}

NonStandardMessage has oddly named fields.

func (*NonStandardMessage) Descriptor deprecated

func (*NonStandardMessage) Descriptor() ([]byte, []int)

Deprecated: Use NonStandardMessage.ProtoReflect.Descriptor instead.

func (*NonStandardMessage) GetEn_GB

func (x *NonStandardMessage) GetEn_GB() int64

func (*NonStandardMessage) GetId

func (x *NonStandardMessage) GetId() string

func (*NonStandardMessage) GetLangIdent

func (x *NonStandardMessage) GetLangIdent() string

func (*NonStandardMessage) GetLineNum

func (x *NonStandardMessage) GetLineNum() int64

func (*NonStandardMessage) GetNo

func (x *NonStandardMessage) GetNo() string

func (*NonStandardMessage) GetNum

func (x *NonStandardMessage) GetNum() int64

func (*NonStandardMessage) GetSTATUS

func (x *NonStandardMessage) GetSTATUS() string

func (*NonStandardMessage) GetThing

func (*NonStandardMessage) ProtoMessage

func (*NonStandardMessage) ProtoMessage()

func (*NonStandardMessage) ProtoReflect

func (x *NonStandardMessage) ProtoReflect() protoreflect.Message

func (*NonStandardMessage) Reset

func (x *NonStandardMessage) Reset()

func (*NonStandardMessage) String

func (x *NonStandardMessage) String() string

type NonStandardMessageWithJSONNames

type NonStandardMessageWithJSONNames struct {

	// Id represents the message identifier.
	Id        string                                 `protobuf:"bytes,1,opt,name=id,json=ID,proto3" json:"id,omitempty"`
	Num       int64                                  `protobuf:"varint,2,opt,name=Num,proto3" json:"Num,omitempty"`
	LineNum   int64                                  `protobuf:"varint,3,opt,name=line_num,json=LineNum,proto3" json:"line_num,omitempty"`
	LangIdent string                                 `protobuf:"bytes,4,opt,name=langIdent,proto3" json:"langIdent,omitempty"`
	STATUS    string                                 `protobuf:"bytes,5,opt,name=STATUS,json=status,proto3" json:"STATUS,omitempty"`
	En_GB     int64                                  `protobuf:"varint,6,opt,name=en_GB,json=En_GB,proto3" json:"en_GB,omitempty"`
	No        string                                 `protobuf:"bytes,7,opt,name=no,json=yes,proto3" json:"no,omitempty"`
	Thing     *NonStandardMessageWithJSONNames_Thing `protobuf:"bytes,8,opt,name=thing,json=Thingy,proto3" json:"thing,omitempty"`
	// contains filtered or unexported fields
}

NonStandardMessageWithJSONNames maps odd field names to odd JSON names for maximum confusion.

func (*NonStandardMessageWithJSONNames) Descriptor deprecated

func (*NonStandardMessageWithJSONNames) Descriptor() ([]byte, []int)

Deprecated: Use NonStandardMessageWithJSONNames.ProtoReflect.Descriptor instead.

func (*NonStandardMessageWithJSONNames) GetEn_GB

func (x *NonStandardMessageWithJSONNames) GetEn_GB() int64

func (*NonStandardMessageWithJSONNames) GetId

func (*NonStandardMessageWithJSONNames) GetLangIdent

func (x *NonStandardMessageWithJSONNames) GetLangIdent() string

func (*NonStandardMessageWithJSONNames) GetLineNum

func (x *NonStandardMessageWithJSONNames) GetLineNum() int64

func (*NonStandardMessageWithJSONNames) GetNo

func (*NonStandardMessageWithJSONNames) GetNum

func (*NonStandardMessageWithJSONNames) GetSTATUS

func (x *NonStandardMessageWithJSONNames) GetSTATUS() string

func (*NonStandardMessageWithJSONNames) GetThing

func (*NonStandardMessageWithJSONNames) ProtoMessage

func (*NonStandardMessageWithJSONNames) ProtoMessage()

func (*NonStandardMessageWithJSONNames) ProtoReflect

func (*NonStandardMessageWithJSONNames) Reset

func (*NonStandardMessageWithJSONNames) String

type NonStandardMessageWithJSONNames_Thing

type NonStandardMessageWithJSONNames_Thing struct {
	SubThing *NonStandardMessageWithJSONNames_Thing_SubThing `protobuf:"bytes,1,opt,name=subThing,json=SubThing,proto3" json:"subThing,omitempty"`
	// contains filtered or unexported fields
}

func (*NonStandardMessageWithJSONNames_Thing) Descriptor deprecated

func (*NonStandardMessageWithJSONNames_Thing) Descriptor() ([]byte, []int)

Deprecated: Use NonStandardMessageWithJSONNames_Thing.ProtoReflect.Descriptor instead.

func (*NonStandardMessageWithJSONNames_Thing) GetSubThing

func (*NonStandardMessageWithJSONNames_Thing) ProtoMessage

func (*NonStandardMessageWithJSONNames_Thing) ProtoMessage()

func (*NonStandardMessageWithJSONNames_Thing) ProtoReflect

func (*NonStandardMessageWithJSONNames_Thing) Reset

func (*NonStandardMessageWithJSONNames_Thing) String

type NonStandardMessageWithJSONNames_Thing_SubThing

type NonStandardMessageWithJSONNames_Thing_SubThing struct {
	SubValue string `protobuf:"bytes,1,opt,name=sub_value,json=sub_Value,proto3" json:"sub_value,omitempty"`
	// contains filtered or unexported fields
}

func (*NonStandardMessageWithJSONNames_Thing_SubThing) Descriptor deprecated

Deprecated: Use NonStandardMessageWithJSONNames_Thing_SubThing.ProtoReflect.Descriptor instead.

func (*NonStandardMessageWithJSONNames_Thing_SubThing) GetSubValue

func (*NonStandardMessageWithJSONNames_Thing_SubThing) ProtoMessage

func (*NonStandardMessageWithJSONNames_Thing_SubThing) ProtoReflect

func (*NonStandardMessageWithJSONNames_Thing_SubThing) Reset

func (*NonStandardMessageWithJSONNames_Thing_SubThing) String

type NonStandardMessage_Thing

type NonStandardMessage_Thing struct {
	SubThing *NonStandardMessage_Thing_SubThing `protobuf:"bytes,1,opt,name=subThing,proto3" json:"subThing,omitempty"`
	// contains filtered or unexported fields
}

func (*NonStandardMessage_Thing) Descriptor deprecated

func (*NonStandardMessage_Thing) Descriptor() ([]byte, []int)

Deprecated: Use NonStandardMessage_Thing.ProtoReflect.Descriptor instead.

func (*NonStandardMessage_Thing) GetSubThing

func (*NonStandardMessage_Thing) ProtoMessage

func (*NonStandardMessage_Thing) ProtoMessage()

func (*NonStandardMessage_Thing) ProtoReflect

func (x *NonStandardMessage_Thing) ProtoReflect() protoreflect.Message

func (*NonStandardMessage_Thing) Reset

func (x *NonStandardMessage_Thing) Reset()

func (*NonStandardMessage_Thing) String

func (x *NonStandardMessage_Thing) String() string

type NonStandardMessage_Thing_SubThing

type NonStandardMessage_Thing_SubThing struct {
	SubValue string `protobuf:"bytes,1,opt,name=sub_value,json=subValue,proto3" json:"sub_value,omitempty"`
	// contains filtered or unexported fields
}

func (*NonStandardMessage_Thing_SubThing) Descriptor deprecated

func (*NonStandardMessage_Thing_SubThing) Descriptor() ([]byte, []int)

Deprecated: Use NonStandardMessage_Thing_SubThing.ProtoReflect.Descriptor instead.

func (*NonStandardMessage_Thing_SubThing) GetSubValue

func (x *NonStandardMessage_Thing_SubThing) GetSubValue() string

func (*NonStandardMessage_Thing_SubThing) ProtoMessage

func (*NonStandardMessage_Thing_SubThing) ProtoMessage()

func (*NonStandardMessage_Thing_SubThing) ProtoReflect

func (*NonStandardMessage_Thing_SubThing) Reset

func (*NonStandardMessage_Thing_SubThing) String

type NonStandardServiceClient

type NonStandardServiceClient interface {
	// Apply field mask to empty NonStandardMessage and return result.
	Update(ctx context.Context, in *NonStandardUpdateRequest, opts ...grpc.CallOption) (*NonStandardMessage, error)
	// Apply field mask to empty NonStandardMessageWithJSONNames and return result.
	UpdateWithJSONNames(ctx context.Context, in *NonStandardWithJSONNamesUpdateRequest, opts ...grpc.CallOption) (*NonStandardMessageWithJSONNames, error)
}

NonStandardServiceClient is the client API for NonStandardService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type NonStandardServiceServer

type NonStandardServiceServer interface {
	// Apply field mask to empty NonStandardMessage and return result.
	Update(context.Context, *NonStandardUpdateRequest) (*NonStandardMessage, error)
	// Apply field mask to empty NonStandardMessageWithJSONNames and return result.
	UpdateWithJSONNames(context.Context, *NonStandardWithJSONNamesUpdateRequest) (*NonStandardMessageWithJSONNames, error)
}

NonStandardServiceServer is the server API for NonStandardService service. All implementations should embed UnimplementedNonStandardServiceServer for forward compatibility

type NonStandardUpdateRequest

type NonStandardUpdateRequest struct {
	Body       *NonStandardMessage    `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// contains filtered or unexported fields
}

func (*NonStandardUpdateRequest) Descriptor deprecated

func (*NonStandardUpdateRequest) Descriptor() ([]byte, []int)

Deprecated: Use NonStandardUpdateRequest.ProtoReflect.Descriptor instead.

func (*NonStandardUpdateRequest) GetBody

func (*NonStandardUpdateRequest) GetUpdateMask

func (x *NonStandardUpdateRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*NonStandardUpdateRequest) ProtoMessage

func (*NonStandardUpdateRequest) ProtoMessage()

func (*NonStandardUpdateRequest) ProtoReflect

func (x *NonStandardUpdateRequest) ProtoReflect() protoreflect.Message

func (*NonStandardUpdateRequest) Reset

func (x *NonStandardUpdateRequest) Reset()

func (*NonStandardUpdateRequest) String

func (x *NonStandardUpdateRequest) String() string

type NonStandardWithJSONNamesUpdateRequest

type NonStandardWithJSONNamesUpdateRequest struct {
	Body       *NonStandardMessageWithJSONNames `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	UpdateMask *fieldmaskpb.FieldMask           `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// contains filtered or unexported fields
}

func (*NonStandardWithJSONNamesUpdateRequest) Descriptor deprecated

func (*NonStandardWithJSONNamesUpdateRequest) Descriptor() ([]byte, []int)

Deprecated: Use NonStandardWithJSONNamesUpdateRequest.ProtoReflect.Descriptor instead.

func (*NonStandardWithJSONNamesUpdateRequest) GetBody

func (*NonStandardWithJSONNamesUpdateRequest) GetUpdateMask

func (*NonStandardWithJSONNamesUpdateRequest) ProtoMessage

func (*NonStandardWithJSONNamesUpdateRequest) ProtoMessage()

func (*NonStandardWithJSONNamesUpdateRequest) ProtoReflect

func (*NonStandardWithJSONNamesUpdateRequest) Reset

func (*NonStandardWithJSONNamesUpdateRequest) String

type NumericEnum

type NumericEnum int32

NumericEnum is one or zero.

const (
	// ZERO means 0
	NumericEnum_ZERO NumericEnum = 0
	// ONE means 1
	NumericEnum_ONE NumericEnum = 1
)

func (NumericEnum) Descriptor

func (NumericEnum) Enum

func (x NumericEnum) Enum() *NumericEnum

func (NumericEnum) EnumDescriptor deprecated

func (NumericEnum) EnumDescriptor() ([]byte, []int)

Deprecated: Use NumericEnum.Descriptor instead.

func (NumericEnum) Number

func (x NumericEnum) Number() protoreflect.EnumNumber

func (NumericEnum) String

func (x NumericEnum) String() string

func (NumericEnum) Type

type OutMessageA

type OutMessageA struct {

	// Here is the explanation about OutMessageA.value
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

OutMessageA represents a message returned from ServiceA.

func (*OutMessageA) Descriptor deprecated

func (*OutMessageA) Descriptor() ([]byte, []int)

Deprecated: Use OutMessageA.ProtoReflect.Descriptor instead.

func (*OutMessageA) GetValue

func (x *OutMessageA) GetValue() string

func (*OutMessageA) ProtoMessage

func (*OutMessageA) ProtoMessage()

func (*OutMessageA) ProtoReflect

func (x *OutMessageA) ProtoReflect() protoreflect.Message

func (*OutMessageA) Reset

func (x *OutMessageA) Reset()

func (*OutMessageA) String

func (x *OutMessageA) String() string

type OutMessageB

type OutMessageB struct {

	// Here is the explanation about OutMessageB.value
	Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

OutMessageB represents a message returned from ServiceB.

func (*OutMessageB) Descriptor deprecated

func (*OutMessageB) Descriptor() ([]byte, []int)

Deprecated: Use OutMessageB.ProtoReflect.Descriptor instead.

func (*OutMessageB) GetValues

func (x *OutMessageB) GetValues() []string

func (*OutMessageB) ProtoMessage

func (*OutMessageB) ProtoMessage()

func (*OutMessageB) ProtoReflect

func (x *OutMessageB) ProtoReflect() protoreflect.Message

func (*OutMessageB) Reset

func (x *OutMessageB) Reset()

func (*OutMessageB) String

func (x *OutMessageB) String() string

type OutMessageC

type OutMessageC struct {

	// Here is the explanation about OutMessageC.value
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

OutMessageC represents a message returned from ServiceC.

func (*OutMessageC) Descriptor deprecated

func (*OutMessageC) Descriptor() ([]byte, []int)

Deprecated: Use OutMessageC.ProtoReflect.Descriptor instead.

func (*OutMessageC) GetValue

func (x *OutMessageC) GetValue() string

func (*OutMessageC) ProtoMessage

func (*OutMessageC) ProtoMessage()

func (*OutMessageC) ProtoReflect

func (x *OutMessageC) ProtoReflect() protoreflect.Message

func (*OutMessageC) Reset

func (x *OutMessageC) Reset()

func (*OutMessageC) String

func (x *OutMessageC) String() string

type RepeatedResponseBodyOut

type RepeatedResponseBodyOut struct {
	Response []*RepeatedResponseBodyOut_Response `protobuf:"bytes,2,rep,name=response,proto3" json:"response,omitempty"`
	// contains filtered or unexported fields
}

func (*RepeatedResponseBodyOut) Descriptor deprecated

func (*RepeatedResponseBodyOut) Descriptor() ([]byte, []int)

Deprecated: Use RepeatedResponseBodyOut.ProtoReflect.Descriptor instead.

func (*RepeatedResponseBodyOut) GetResponse

func (*RepeatedResponseBodyOut) ProtoMessage

func (*RepeatedResponseBodyOut) ProtoMessage()

func (*RepeatedResponseBodyOut) ProtoReflect

func (x *RepeatedResponseBodyOut) ProtoReflect() protoreflect.Message

func (*RepeatedResponseBodyOut) Reset

func (x *RepeatedResponseBodyOut) Reset()

func (*RepeatedResponseBodyOut) String

func (x *RepeatedResponseBodyOut) String() string

type RepeatedResponseBodyOut_Response

type RepeatedResponseBodyOut_Response struct {
	Data string                                        `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	Type RepeatedResponseBodyOut_Response_ResponseType `` /* 160-byte string literal not displayed */
	// contains filtered or unexported fields
}

func (*RepeatedResponseBodyOut_Response) Descriptor deprecated

func (*RepeatedResponseBodyOut_Response) Descriptor() ([]byte, []int)

Deprecated: Use RepeatedResponseBodyOut_Response.ProtoReflect.Descriptor instead.

func (*RepeatedResponseBodyOut_Response) GetData

func (*RepeatedResponseBodyOut_Response) GetType

func (*RepeatedResponseBodyOut_Response) ProtoMessage

func (*RepeatedResponseBodyOut_Response) ProtoMessage()

func (*RepeatedResponseBodyOut_Response) ProtoReflect

func (*RepeatedResponseBodyOut_Response) Reset

func (*RepeatedResponseBodyOut_Response) String

type RepeatedResponseBodyOut_Response_ResponseType

type RepeatedResponseBodyOut_Response_ResponseType int32
const (
	// UNKNOWN
	RepeatedResponseBodyOut_Response_UNKNOWN RepeatedResponseBodyOut_Response_ResponseType = 0
	// A is 1
	RepeatedResponseBodyOut_Response_A RepeatedResponseBodyOut_Response_ResponseType = 1
	// B is 2
	RepeatedResponseBodyOut_Response_B RepeatedResponseBodyOut_Response_ResponseType = 2
)

func (RepeatedResponseBodyOut_Response_ResponseType) Descriptor

func (RepeatedResponseBodyOut_Response_ResponseType) Enum

func (RepeatedResponseBodyOut_Response_ResponseType) EnumDescriptor deprecated

func (RepeatedResponseBodyOut_Response_ResponseType) EnumDescriptor() ([]byte, []int)

Deprecated: Use RepeatedResponseBodyOut_Response_ResponseType.Descriptor instead.

func (RepeatedResponseBodyOut_Response_ResponseType) Number

func (RepeatedResponseBodyOut_Response_ResponseType) String

func (RepeatedResponseBodyOut_Response_ResponseType) Type

type RepeatedResponseStrings

type RepeatedResponseStrings struct {
	Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

func (*RepeatedResponseStrings) Descriptor deprecated

func (*RepeatedResponseStrings) Descriptor() ([]byte, []int)

Deprecated: Use RepeatedResponseStrings.ProtoReflect.Descriptor instead.

func (*RepeatedResponseStrings) GetValues

func (x *RepeatedResponseStrings) GetValues() []string

func (*RepeatedResponseStrings) ProtoMessage

func (*RepeatedResponseStrings) ProtoMessage()

func (*RepeatedResponseStrings) ProtoReflect

func (x *RepeatedResponseStrings) ProtoReflect() protoreflect.Message

func (*RepeatedResponseStrings) Reset

func (x *RepeatedResponseStrings) Reset()

func (*RepeatedResponseStrings) String

func (x *RepeatedResponseStrings) String() string

type ResponseBodyIn

type ResponseBodyIn struct {
	Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

func (*ResponseBodyIn) Descriptor deprecated

func (*ResponseBodyIn) Descriptor() ([]byte, []int)

Deprecated: Use ResponseBodyIn.ProtoReflect.Descriptor instead.

func (*ResponseBodyIn) GetData

func (x *ResponseBodyIn) GetData() string

func (*ResponseBodyIn) ProtoMessage

func (*ResponseBodyIn) ProtoMessage()

func (*ResponseBodyIn) ProtoReflect

func (x *ResponseBodyIn) ProtoReflect() protoreflect.Message

func (*ResponseBodyIn) Reset

func (x *ResponseBodyIn) Reset()

func (*ResponseBodyIn) String

func (x *ResponseBodyIn) String() string

type ResponseBodyOut

type ResponseBodyOut struct {
	Response *ResponseBodyOut_Response `protobuf:"bytes,2,opt,name=response,proto3" json:"response,omitempty"`
	// contains filtered or unexported fields
}

func (*ResponseBodyOut) Descriptor deprecated

func (*ResponseBodyOut) Descriptor() ([]byte, []int)

Deprecated: Use ResponseBodyOut.ProtoReflect.Descriptor instead.

func (*ResponseBodyOut) GetResponse

func (x *ResponseBodyOut) GetResponse() *ResponseBodyOut_Response

func (*ResponseBodyOut) ProtoMessage

func (*ResponseBodyOut) ProtoMessage()

func (*ResponseBodyOut) ProtoReflect

func (x *ResponseBodyOut) ProtoReflect() protoreflect.Message

func (*ResponseBodyOut) Reset

func (x *ResponseBodyOut) Reset()

func (*ResponseBodyOut) String

func (x *ResponseBodyOut) String() string

type ResponseBodyOut_Response

type ResponseBodyOut_Response struct {
	Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

func (*ResponseBodyOut_Response) Descriptor deprecated

func (*ResponseBodyOut_Response) Descriptor() ([]byte, []int)

Deprecated: Use ResponseBodyOut_Response.ProtoReflect.Descriptor instead.

func (*ResponseBodyOut_Response) GetData

func (x *ResponseBodyOut_Response) GetData() string

func (*ResponseBodyOut_Response) ProtoMessage

func (*ResponseBodyOut_Response) ProtoMessage()

func (*ResponseBodyOut_Response) ProtoReflect

func (x *ResponseBodyOut_Response) ProtoReflect() protoreflect.Message

func (*ResponseBodyOut_Response) Reset

func (x *ResponseBodyOut_Response) Reset()

func (*ResponseBodyOut_Response) String

func (x *ResponseBodyOut_Response) String() string

type ResponseBodyServiceClient

type ResponseBodyServiceClient interface {
	GetResponseBody(ctx context.Context, in *ResponseBodyIn, opts ...grpc.CallOption) (*ResponseBodyOut, error)
	ListResponseBodies(ctx context.Context, in *ResponseBodyIn, opts ...grpc.CallOption) (*RepeatedResponseBodyOut, error)
	ListResponseStrings(ctx context.Context, in *ResponseBodyIn, opts ...grpc.CallOption) (*RepeatedResponseStrings, error)
	GetResponseBodyStream(ctx context.Context, in *ResponseBodyIn, opts ...grpc.CallOption) (ResponseBodyService_GetResponseBodyStreamClient, error)
}

ResponseBodyServiceClient is the client API for ResponseBodyService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type ResponseBodyServiceServer

type ResponseBodyServiceServer interface {
	GetResponseBody(context.Context, *ResponseBodyIn) (*ResponseBodyOut, error)
	ListResponseBodies(context.Context, *ResponseBodyIn) (*RepeatedResponseBodyOut, error)
	ListResponseStrings(context.Context, *ResponseBodyIn) (*RepeatedResponseStrings, error)
	GetResponseBodyStream(*ResponseBodyIn, ResponseBodyService_GetResponseBodyStreamServer) error
}

ResponseBodyServiceServer is the server API for ResponseBodyService service. All implementations should embed UnimplementedResponseBodyServiceServer for forward compatibility

type ResponseBodyService_GetResponseBodyStreamClient

type ResponseBodyService_GetResponseBodyStreamClient interface {
	Recv() (*ResponseBodyOut, error)
	grpc.ClientStream
}

type ResponseBodyService_GetResponseBodyStreamServer

type ResponseBodyService_GetResponseBodyStreamServer interface {
	Send(*ResponseBodyOut) error
	grpc.ServerStream
}

type ServiceAClient

type ServiceAClient interface {
	// ServiceA.MethodOne receives InMessageA and returns OutMessageA
	//
	// Here is the detail explanation about ServiceA.MethodOne.
	MethodOne(ctx context.Context, in *InMessageA, opts ...grpc.CallOption) (*OutMessageA, error)
	// ServiceA.MethodTwo receives OutMessageA and returns InMessageA
	//
	// Here is the detail explanation about ServiceA.MethodTwo.
	MethodTwo(ctx context.Context, in *OutMessageA, opts ...grpc.CallOption) (*InMessageA, error)
}

ServiceAClient is the client API for ServiceA service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewServiceAClient

func NewServiceAClient(cc grpc.ClientConnInterface) ServiceAClient

type ServiceAServer

type ServiceAServer interface {
	// ServiceA.MethodOne receives InMessageA and returns OutMessageA
	//
	// Here is the detail explanation about ServiceA.MethodOne.
	MethodOne(context.Context, *InMessageA) (*OutMessageA, error)
	// ServiceA.MethodTwo receives OutMessageA and returns InMessageA
	//
	// Here is the detail explanation about ServiceA.MethodTwo.
	MethodTwo(context.Context, *OutMessageA) (*InMessageA, error)
}

ServiceAServer is the server API for ServiceA service. All implementations should embed UnimplementedServiceAServer for forward compatibility

type ServiceBClient

type ServiceBClient interface {
	// ServiceB.MethodOne receives InMessageB and returns OutMessageB
	//
	// Here is the detail explanation about ServiceB.MethodOne.
	MethodOne(ctx context.Context, in *InMessageB, opts ...grpc.CallOption) (*OutMessageB, error)
	// ServiceB.MethodTwo receives OutMessageB and returns InMessageB
	//
	// Here is the detail explanation about ServiceB.MethodTwo.
	MethodTwo(ctx context.Context, in *OutMessageB, opts ...grpc.CallOption) (*InMessageB, error)
}

ServiceBClient is the client API for ServiceB service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewServiceBClient

func NewServiceBClient(cc grpc.ClientConnInterface) ServiceBClient

type ServiceBServer

type ServiceBServer interface {
	// ServiceB.MethodOne receives InMessageB and returns OutMessageB
	//
	// Here is the detail explanation about ServiceB.MethodOne.
	MethodOne(context.Context, *InMessageB) (*OutMessageB, error)
	// ServiceB.MethodTwo receives OutMessageB and returns InMessageB
	//
	// Here is the detail explanation about ServiceB.MethodTwo.
	MethodTwo(context.Context, *OutMessageB) (*InMessageB, error)
}

ServiceBServer is the server API for ServiceB service. All implementations should embed UnimplementedServiceBServer for forward compatibility

type ServiceCClient

type ServiceCClient interface {
	// ServiceC.MethodOne receives InMessageA and returns OutMessageC
	//
	// Here is the detail explanation about ServiceC.MethodOne.
	MethodOne(ctx context.Context, in *InMessageA, opts ...grpc.CallOption) (*OutMessageC, error)
	// ServiceC.MethodTwo receives OutMessageA and returns InMessageA
	//
	// Here is the detail explanation about ServiceC.MethodTwo.
	MethodTwo(ctx context.Context, in *OutMessageA, opts ...grpc.CallOption) (*InMessageA, error)
}

ServiceCClient is the client API for ServiceC service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewServiceCClient

func NewServiceCClient(cc grpc.ClientConnInterface) ServiceCClient

type ServiceCServer

type ServiceCServer interface {
	// ServiceC.MethodOne receives InMessageA and returns OutMessageC
	//
	// Here is the detail explanation about ServiceC.MethodOne.
	MethodOne(context.Context, *InMessageA) (*OutMessageC, error)
	// ServiceC.MethodTwo receives OutMessageA and returns InMessageA
	//
	// Here is the detail explanation about ServiceC.MethodTwo.
	MethodTwo(context.Context, *OutMessageA) (*InMessageA, error)
}

ServiceCServer is the server API for ServiceC service. All implementations should embed UnimplementedServiceCServer for forward compatibility

type SimpleMessage

type SimpleMessage struct {

	// Id represents the message identifier.
	Id  string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Num int64  `protobuf:"varint,2,opt,name=num,proto3" json:"num,omitempty"`
	// Types that are assignable to Code:
	//	*SimpleMessage_LineNum
	//	*SimpleMessage_Lang
	Code   isSimpleMessage_Code `protobuf_oneof:"code"`
	Status *Embedded            `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
	// Types that are assignable to Ext:
	//	*SimpleMessage_En
	//	*SimpleMessage_No
	Ext isSimpleMessage_Ext `protobuf_oneof:"ext"`
	// contains filtered or unexported fields
}

SimpleMessage represents a simple message sent to the Echo service.

func (*SimpleMessage) Descriptor deprecated

func (*SimpleMessage) Descriptor() ([]byte, []int)

Deprecated: Use SimpleMessage.ProtoReflect.Descriptor instead.

func (*SimpleMessage) GetCode

func (m *SimpleMessage) GetCode() isSimpleMessage_Code

func (*SimpleMessage) GetEn

func (x *SimpleMessage) GetEn() int64

func (*SimpleMessage) GetExt

func (m *SimpleMessage) GetExt() isSimpleMessage_Ext

func (*SimpleMessage) GetId

func (x *SimpleMessage) GetId() string

func (*SimpleMessage) GetLang

func (x *SimpleMessage) GetLang() string

func (*SimpleMessage) GetLineNum

func (x *SimpleMessage) GetLineNum() int64

func (*SimpleMessage) GetNo

func (x *SimpleMessage) GetNo() *Embedded

func (*SimpleMessage) GetNum

func (x *SimpleMessage) GetNum() int64

func (*SimpleMessage) GetStatus

func (x *SimpleMessage) GetStatus() *Embedded

func (*SimpleMessage) ProtoMessage

func (*SimpleMessage) ProtoMessage()

func (*SimpleMessage) ProtoReflect

func (x *SimpleMessage) ProtoReflect() protoreflect.Message

func (*SimpleMessage) Reset

func (x *SimpleMessage) Reset()

func (*SimpleMessage) String

func (x *SimpleMessage) String() string

type SimpleMessage_En

type SimpleMessage_En struct {
	En int64 `protobuf:"varint,6,opt,name=en,proto3,oneof"`
}

type SimpleMessage_Lang

type SimpleMessage_Lang struct {
	Lang string `protobuf:"bytes,4,opt,name=lang,proto3,oneof"`
}

type SimpleMessage_LineNum

type SimpleMessage_LineNum struct {
	LineNum int64 `protobuf:"varint,3,opt,name=line_num,json=lineNum,proto3,oneof"`
}

type SimpleMessage_No

type SimpleMessage_No struct {
	No *Embedded `protobuf:"bytes,7,opt,name=no,proto3,oneof"`
}

type SingleNestedProto

type SingleNestedProto struct {
	A *UnaryProto `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"`
	// contains filtered or unexported fields
}

func (*SingleNestedProto) Descriptor deprecated

func (*SingleNestedProto) Descriptor() ([]byte, []int)

Deprecated: Use SingleNestedProto.ProtoReflect.Descriptor instead.

func (*SingleNestedProto) GetA

func (x *SingleNestedProto) GetA() *UnaryProto

func (*SingleNestedProto) ProtoMessage

func (*SingleNestedProto) ProtoMessage()

func (*SingleNestedProto) ProtoReflect

func (x *SingleNestedProto) ProtoReflect() protoreflect.Message

func (*SingleNestedProto) Reset

func (x *SingleNestedProto) Reset()

func (*SingleNestedProto) String

func (x *SingleNestedProto) String() string

type StreamServiceClient

type StreamServiceClient interface {
	BulkCreate(ctx context.Context, opts ...grpc.CallOption) (StreamService_BulkCreateClient, error)
	List(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (StreamService_ListClient, error)
	BulkEcho(ctx context.Context, opts ...grpc.CallOption) (StreamService_BulkEchoClient, error)
	Download(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (StreamService_DownloadClient, error)
}

StreamServiceClient is the client API for StreamService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type StreamServiceServer

StreamServiceServer is the server API for StreamService service. All implementations should embed UnimplementedStreamServiceServer for forward compatibility

type StreamService_BulkCreateClient

type StreamService_BulkCreateClient interface {
	Send(*ABitOfEverything) error
	CloseAndRecv() (*emptypb.Empty, error)
	grpc.ClientStream
}

type StreamService_BulkCreateServer

type StreamService_BulkCreateServer interface {
	SendAndClose(*emptypb.Empty) error
	Recv() (*ABitOfEverything, error)
	grpc.ServerStream
}

type StreamService_BulkEchoClient

type StreamService_BulkEchoClient interface {
	Send(*sub.StringMessage) error
	Recv() (*sub.StringMessage, error)
	grpc.ClientStream
}

type StreamService_BulkEchoServer

type StreamService_BulkEchoServer interface {
	Send(*sub.StringMessage) error
	Recv() (*sub.StringMessage, error)
	grpc.ServerStream
}

type StreamService_DownloadClient

type StreamService_DownloadClient interface {
	Recv() (*httpbody.HttpBody, error)
	grpc.ClientStream
}

type StreamService_DownloadServer

type StreamService_DownloadServer interface {
	Send(*httpbody.HttpBody) error
	grpc.ServerStream
}

type StreamService_ListClient

type StreamService_ListClient interface {
	Recv() (*ABitOfEverything, error)
	grpc.ClientStream
}

type StreamService_ListServer

type StreamService_ListServer interface {
	Send(*ABitOfEverything) error
	grpc.ServerStream
}

type UnannotatedEchoServiceClient

type UnannotatedEchoServiceClient interface {
	// Echo method receives a simple message and returns it.
	//
	// The message posted as the id parameter will also be
	// returned.
	Echo(ctx context.Context, in *UnannotatedSimpleMessage, opts ...grpc.CallOption) (*UnannotatedSimpleMessage, error)
	// EchoBody method receives a simple message and returns it.
	EchoBody(ctx context.Context, in *UnannotatedSimpleMessage, opts ...grpc.CallOption) (*UnannotatedSimpleMessage, error)
	// EchoDelete method receives a simple message and returns it.
	EchoDelete(ctx context.Context, in *UnannotatedSimpleMessage, opts ...grpc.CallOption) (*UnannotatedSimpleMessage, error)
}

UnannotatedEchoServiceClient is the client API for UnannotatedEchoService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type UnannotatedEchoServiceServer

type UnannotatedEchoServiceServer interface {
	// Echo method receives a simple message and returns it.
	//
	// The message posted as the id parameter will also be
	// returned.
	Echo(context.Context, *UnannotatedSimpleMessage) (*UnannotatedSimpleMessage, error)
	// EchoBody method receives a simple message and returns it.
	EchoBody(context.Context, *UnannotatedSimpleMessage) (*UnannotatedSimpleMessage, error)
	// EchoDelete method receives a simple message and returns it.
	EchoDelete(context.Context, *UnannotatedSimpleMessage) (*UnannotatedSimpleMessage, error)
}

UnannotatedEchoServiceServer is the server API for UnannotatedEchoService service. All implementations should embed UnimplementedUnannotatedEchoServiceServer for forward compatibility

type UnannotatedEmbedded

type UnannotatedEmbedded struct {

	// Types that are assignable to Mark:
	//	*UnannotatedEmbedded_Progress
	//	*UnannotatedEmbedded_Note
	Mark isUnannotatedEmbedded_Mark `protobuf_oneof:"mark"`
	// contains filtered or unexported fields
}

Embedded represents a message embedded in SimpleMessage.

func (*UnannotatedEmbedded) Descriptor deprecated

func (*UnannotatedEmbedded) Descriptor() ([]byte, []int)

Deprecated: Use UnannotatedEmbedded.ProtoReflect.Descriptor instead.

func (*UnannotatedEmbedded) GetMark

func (m *UnannotatedEmbedded) GetMark() isUnannotatedEmbedded_Mark

func (*UnannotatedEmbedded) GetNote

func (x *UnannotatedEmbedded) GetNote() string

func (*UnannotatedEmbedded) GetProgress

func (x *UnannotatedEmbedded) GetProgress() int64

func (*UnannotatedEmbedded) ProtoMessage

func (*UnannotatedEmbedded) ProtoMessage()

func (*UnannotatedEmbedded) ProtoReflect

func (x *UnannotatedEmbedded) ProtoReflect() protoreflect.Message

func (*UnannotatedEmbedded) Reset

func (x *UnannotatedEmbedded) Reset()

func (*UnannotatedEmbedded) String

func (x *UnannotatedEmbedded) String() string

type UnannotatedEmbedded_Note

type UnannotatedEmbedded_Note struct {
	Note string `protobuf:"bytes,2,opt,name=note,proto3,oneof"`
}

type UnannotatedEmbedded_Progress

type UnannotatedEmbedded_Progress struct {
	Progress int64 `protobuf:"varint,1,opt,name=progress,proto3,oneof"`
}

type UnannotatedSimpleMessage

type UnannotatedSimpleMessage struct {

	// Id represents the message identifier.
	Id       string               `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Num      int64                `protobuf:"varint,2,opt,name=num,proto3" json:"num,omitempty"`
	Duration *durationpb.Duration `protobuf:"bytes,3,opt,name=duration,proto3" json:"duration,omitempty"`
	// Types that are assignable to Code:
	//	*UnannotatedSimpleMessage_LineNum
	//	*UnannotatedSimpleMessage_Lang
	Code   isUnannotatedSimpleMessage_Code `protobuf_oneof:"code"`
	Status *UnannotatedEmbedded            `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"`
	// Types that are assignable to Ext:
	//	*UnannotatedSimpleMessage_En
	//	*UnannotatedSimpleMessage_No
	Ext isUnannotatedSimpleMessage_Ext `protobuf_oneof:"ext"`
	// contains filtered or unexported fields
}

UnannotatedSimpleMessage represents a simple message sent to the unannotated Echo service.

func (*UnannotatedSimpleMessage) Descriptor deprecated

func (*UnannotatedSimpleMessage) Descriptor() ([]byte, []int)

Deprecated: Use UnannotatedSimpleMessage.ProtoReflect.Descriptor instead.

func (*UnannotatedSimpleMessage) GetCode

func (m *UnannotatedSimpleMessage) GetCode() isUnannotatedSimpleMessage_Code

func (*UnannotatedSimpleMessage) GetDuration

func (x *UnannotatedSimpleMessage) GetDuration() *durationpb.Duration

func (*UnannotatedSimpleMessage) GetEn

func (x *UnannotatedSimpleMessage) GetEn() int64

func (*UnannotatedSimpleMessage) GetExt

func (m *UnannotatedSimpleMessage) GetExt() isUnannotatedSimpleMessage_Ext

func (*UnannotatedSimpleMessage) GetId

func (x *UnannotatedSimpleMessage) GetId() string

func (*UnannotatedSimpleMessage) GetLang

func (x *UnannotatedSimpleMessage) GetLang() string

func (*UnannotatedSimpleMessage) GetLineNum

func (x *UnannotatedSimpleMessage) GetLineNum() int64

func (*UnannotatedSimpleMessage) GetNo

func (*UnannotatedSimpleMessage) GetNum

func (x *UnannotatedSimpleMessage) GetNum() int64

func (*UnannotatedSimpleMessage) GetStatus

func (*UnannotatedSimpleMessage) ProtoMessage

func (*UnannotatedSimpleMessage) ProtoMessage()

func (*UnannotatedSimpleMessage) ProtoReflect

func (x *UnannotatedSimpleMessage) ProtoReflect() protoreflect.Message

func (*UnannotatedSimpleMessage) Reset

func (x *UnannotatedSimpleMessage) Reset()

func (*UnannotatedSimpleMessage) String

func (x *UnannotatedSimpleMessage) String() string

type UnannotatedSimpleMessage_En

type UnannotatedSimpleMessage_En struct {
	En int64 `protobuf:"varint,7,opt,name=en,proto3,oneof"`
}

type UnannotatedSimpleMessage_Lang

type UnannotatedSimpleMessage_Lang struct {
	Lang string `protobuf:"bytes,5,opt,name=lang,proto3,oneof"`
}

type UnannotatedSimpleMessage_LineNum

type UnannotatedSimpleMessage_LineNum struct {
	LineNum int64 `protobuf:"varint,4,opt,name=line_num,json=lineNum,proto3,oneof"`
}

type UnannotatedSimpleMessage_No

type UnannotatedSimpleMessage_No struct {
	No *UnannotatedEmbedded `protobuf:"bytes,8,opt,name=no,proto3,oneof"`
}

type UnaryProto

type UnaryProto struct {
	Str string `protobuf:"bytes,1,opt,name=str,proto3" json:"str,omitempty"`
	// contains filtered or unexported fields
}

func (*UnaryProto) Descriptor deprecated

func (*UnaryProto) Descriptor() ([]byte, []int)

Deprecated: Use UnaryProto.ProtoReflect.Descriptor instead.

func (*UnaryProto) GetStr

func (x *UnaryProto) GetStr() string

func (*UnaryProto) ProtoMessage

func (*UnaryProto) ProtoMessage()

func (*UnaryProto) ProtoReflect

func (x *UnaryProto) ProtoReflect() protoreflect.Message

func (*UnaryProto) Reset

func (x *UnaryProto) Reset()

func (*UnaryProto) String

func (x *UnaryProto) String() string

type UnimplementedABitOfEverythingServiceServer

type UnimplementedABitOfEverythingServiceServer struct {
}

UnimplementedABitOfEverythingServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedABitOfEverythingServiceServer) CheckExternalNestedPathEnum

func (UnimplementedABitOfEverythingServiceServer) CheckExternalPathEnum

func (UnimplementedABitOfEverythingServiceServer) CheckGetQueryParams

func (UnimplementedABitOfEverythingServiceServer) CheckNestedEnumGetQueryParams

func (UnimplementedABitOfEverythingServiceServer) CheckPostQueryParams

func (UnimplementedABitOfEverythingServiceServer) CheckStatus

func (UnimplementedABitOfEverythingServiceServer) Create

func (UnimplementedABitOfEverythingServiceServer) CreateBody

func (UnimplementedABitOfEverythingServiceServer) CreateBook

func (UnimplementedABitOfEverythingServiceServer) DeepPathEcho

func (UnimplementedABitOfEverythingServiceServer) Delete

func (UnimplementedABitOfEverythingServiceServer) Echo

func (UnimplementedABitOfEverythingServiceServer) ErrorWithDetails

func (UnimplementedABitOfEverythingServiceServer) GetMessageWithBody

func (UnimplementedABitOfEverythingServiceServer) GetQuery

func (UnimplementedABitOfEverythingServiceServer) GetRepeatedQuery

func (UnimplementedABitOfEverythingServiceServer) Lookup

func (UnimplementedABitOfEverythingServiceServer) NoBindings

func (UnimplementedABitOfEverythingServiceServer) OverwriteResponseContentType

func (UnimplementedABitOfEverythingServiceServer) PostWithEmptyBody

func (UnimplementedABitOfEverythingServiceServer) Timeout

func (UnimplementedABitOfEverythingServiceServer) Update

func (UnimplementedABitOfEverythingServiceServer) UpdateBook

func (UnimplementedABitOfEverythingServiceServer) UpdateV2

type UnimplementedAnotherServiceWithNoBindingsServer

type UnimplementedAnotherServiceWithNoBindingsServer struct {
}

UnimplementedAnotherServiceWithNoBindingsServer should be embedded to have forward compatible implementations.

func (UnimplementedAnotherServiceWithNoBindingsServer) NoBindings

type UnimplementedCamelCaseServiceNameServer

type UnimplementedCamelCaseServiceNameServer struct {
}

UnimplementedCamelCaseServiceNameServer should be embedded to have forward compatible implementations.

func (UnimplementedCamelCaseServiceNameServer) Empty

type UnimplementedEchoServiceServer

type UnimplementedEchoServiceServer struct {
}

UnimplementedEchoServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedEchoServiceServer) Echo

func (UnimplementedEchoServiceServer) EchoBody

func (UnimplementedEchoServiceServer) EchoDelete

func (UnimplementedEchoServiceServer) EchoPatch

func (UnimplementedEchoServiceServer) EchoUnauthorized

type UnimplementedFlowCombinationServer

type UnimplementedFlowCombinationServer struct {
}

UnimplementedFlowCombinationServer should be embedded to have forward compatible implementations.

func (UnimplementedFlowCombinationServer) RpcBodyRpc

func (UnimplementedFlowCombinationServer) RpcBodyStream

func (UnimplementedFlowCombinationServer) RpcEmptyRpc

func (UnimplementedFlowCombinationServer) RpcEmptyStream

func (UnimplementedFlowCombinationServer) RpcPathNestedRpc

func (UnimplementedFlowCombinationServer) RpcPathNestedStream

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedRpc

func (UnimplementedFlowCombinationServer) StreamEmptyRpc

func (UnimplementedFlowCombinationServer) StreamEmptyStream

type UnimplementedGenerateUnboundMethodsEchoServiceServer

type UnimplementedGenerateUnboundMethodsEchoServiceServer struct {
}

UnimplementedGenerateUnboundMethodsEchoServiceServer should be embedded to have forward compatible implementations.

type UnimplementedLoginServiceServer

type UnimplementedLoginServiceServer struct {
}

UnimplementedLoginServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedLoginServiceServer) Login

func (UnimplementedLoginServiceServer) Logout

type UnimplementedNonStandardServiceServer

type UnimplementedNonStandardServiceServer struct {
}

UnimplementedNonStandardServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedNonStandardServiceServer) Update

type UnimplementedResponseBodyServiceServer

type UnimplementedResponseBodyServiceServer struct {
}

UnimplementedResponseBodyServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedResponseBodyServiceServer) GetResponseBody

func (UnimplementedResponseBodyServiceServer) GetResponseBodyStream

func (UnimplementedResponseBodyServiceServer) ListResponseBodies

func (UnimplementedResponseBodyServiceServer) ListResponseStrings

type UnimplementedServiceAServer

type UnimplementedServiceAServer struct {
}

UnimplementedServiceAServer should be embedded to have forward compatible implementations.

func (UnimplementedServiceAServer) MethodOne

func (UnimplementedServiceAServer) MethodTwo

type UnimplementedServiceBServer

type UnimplementedServiceBServer struct {
}

UnimplementedServiceBServer should be embedded to have forward compatible implementations.

func (UnimplementedServiceBServer) MethodOne

func (UnimplementedServiceBServer) MethodTwo

type UnimplementedServiceCServer

type UnimplementedServiceCServer struct {
}

UnimplementedServiceCServer should be embedded to have forward compatible implementations.

func (UnimplementedServiceCServer) MethodOne

func (UnimplementedServiceCServer) MethodTwo

type UnimplementedStreamServiceServer

type UnimplementedStreamServiceServer struct {
}

UnimplementedStreamServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedStreamServiceServer) BulkCreate

func (UnimplementedStreamServiceServer) BulkEcho

func (UnimplementedStreamServiceServer) Download

func (UnimplementedStreamServiceServer) List

type UnimplementedUnannotatedEchoServiceServer

type UnimplementedUnannotatedEchoServiceServer struct {
}

UnimplementedUnannotatedEchoServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedUnannotatedEchoServiceServer) Echo

func (UnimplementedUnannotatedEchoServiceServer) EchoBody

func (UnimplementedUnannotatedEchoServiceServer) EchoDelete

type UnimplementedWrappersServiceServer

type UnimplementedWrappersServiceServer struct {
}

UnimplementedWrappersServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedWrappersServiceServer) Create

func (UnimplementedWrappersServiceServer) CreateBoolValue

func (UnimplementedWrappersServiceServer) CreateBytesValue

func (UnimplementedWrappersServiceServer) CreateDoubleValue

func (UnimplementedWrappersServiceServer) CreateEmpty

func (UnimplementedWrappersServiceServer) CreateFloatValue

func (UnimplementedWrappersServiceServer) CreateInt32Value

func (UnimplementedWrappersServiceServer) CreateInt64Value

func (UnimplementedWrappersServiceServer) CreateStringValue

func (UnimplementedWrappersServiceServer) CreateUInt32Value

func (UnimplementedWrappersServiceServer) CreateUInt64Value

type UnsafeABitOfEverythingServiceServer

type UnsafeABitOfEverythingServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeABitOfEverythingServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ABitOfEverythingServiceServer will result in compilation errors.

type UnsafeAnotherServiceWithNoBindingsServer

type UnsafeAnotherServiceWithNoBindingsServer interface {
	// contains filtered or unexported methods
}

UnsafeAnotherServiceWithNoBindingsServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to AnotherServiceWithNoBindingsServer will result in compilation errors.

type UnsafeCamelCaseServiceNameServer

type UnsafeCamelCaseServiceNameServer interface {
	// contains filtered or unexported methods
}

UnsafeCamelCaseServiceNameServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to CamelCaseServiceNameServer will result in compilation errors.

type UnsafeEchoServiceServer

type UnsafeEchoServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeEchoServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to EchoServiceServer will result in compilation errors.

type UnsafeFlowCombinationServer

type UnsafeFlowCombinationServer interface {
	// contains filtered or unexported methods
}

UnsafeFlowCombinationServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to FlowCombinationServer will result in compilation errors.

type UnsafeGenerateUnboundMethodsEchoServiceServer

type UnsafeGenerateUnboundMethodsEchoServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeGenerateUnboundMethodsEchoServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to GenerateUnboundMethodsEchoServiceServer will result in compilation errors.

type UnsafeLoginServiceServer

type UnsafeLoginServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeLoginServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to LoginServiceServer will result in compilation errors.

type UnsafeNonStandardServiceServer

type UnsafeNonStandardServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeNonStandardServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to NonStandardServiceServer will result in compilation errors.

type UnsafeResponseBodyServiceServer

type UnsafeResponseBodyServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeResponseBodyServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ResponseBodyServiceServer will result in compilation errors.

type UnsafeServiceAServer

type UnsafeServiceAServer interface {
	// contains filtered or unexported methods
}

UnsafeServiceAServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ServiceAServer will result in compilation errors.

type UnsafeServiceBServer

type UnsafeServiceBServer interface {
	// contains filtered or unexported methods
}

UnsafeServiceBServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ServiceBServer will result in compilation errors.

type UnsafeServiceCServer

type UnsafeServiceCServer interface {
	// contains filtered or unexported methods
}

UnsafeServiceCServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ServiceCServer will result in compilation errors.

type UnsafeStreamServiceServer

type UnsafeStreamServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeStreamServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to StreamServiceServer will result in compilation errors.

type UnsafeUnannotatedEchoServiceServer

type UnsafeUnannotatedEchoServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeUnannotatedEchoServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to UnannotatedEchoServiceServer will result in compilation errors.

type UnsafeWrappersServiceServer

type UnsafeWrappersServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeWrappersServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to WrappersServiceServer will result in compilation errors.

type UpdateBookRequest

type UpdateBookRequest struct {

	// The book to update.
	//
	// The book's `name` field is used to identify the book to be updated.
	// Format: publishers/{publisher}/books/{book}
	Book *Book `protobuf:"bytes,1,opt,name=book,proto3" json:"book,omitempty"`
	// The list of fields to be updated.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// If set to true, and the book is not found, a new book will be created.
	// In this situation, `update_mask` is ignored.
	AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`
	// contains filtered or unexported fields
}

A standard Update message from AIP-134

See: https://google.aip.dev/134#request-message

func (*UpdateBookRequest) Descriptor deprecated

func (*UpdateBookRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpdateBookRequest.ProtoReflect.Descriptor instead.

func (*UpdateBookRequest) GetAllowMissing

func (x *UpdateBookRequest) GetAllowMissing() bool

func (*UpdateBookRequest) GetBook

func (x *UpdateBookRequest) GetBook() *Book

func (*UpdateBookRequest) GetUpdateMask

func (x *UpdateBookRequest) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateBookRequest) ProtoMessage

func (*UpdateBookRequest) ProtoMessage()

func (*UpdateBookRequest) ProtoReflect

func (x *UpdateBookRequest) ProtoReflect() protoreflect.Message

func (*UpdateBookRequest) Reset

func (x *UpdateBookRequest) Reset()

func (*UpdateBookRequest) String

func (x *UpdateBookRequest) String() string

type UpdateV2Request

type UpdateV2Request struct {
	Abe *ABitOfEverything `protobuf:"bytes,1,opt,name=abe,proto3" json:"abe,omitempty"`
	// The paths to update.
	UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
	// contains filtered or unexported fields
}

UpdateV2Request request for update includes the message and the update mask

func (*UpdateV2Request) Descriptor deprecated

func (*UpdateV2Request) Descriptor() ([]byte, []int)

Deprecated: Use UpdateV2Request.ProtoReflect.Descriptor instead.

func (*UpdateV2Request) GetAbe

func (x *UpdateV2Request) GetAbe() *ABitOfEverything

func (*UpdateV2Request) GetUpdateMask

func (x *UpdateV2Request) GetUpdateMask() *fieldmaskpb.FieldMask

func (*UpdateV2Request) ProtoMessage

func (*UpdateV2Request) ProtoMessage()

func (*UpdateV2Request) ProtoReflect

func (x *UpdateV2Request) ProtoReflect() protoreflect.Message

func (*UpdateV2Request) Reset

func (x *UpdateV2Request) Reset()

func (*UpdateV2Request) String

func (x *UpdateV2Request) String() string

type Wrappers

type Wrappers struct {
	StringValue *wrapperspb.StringValue `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3" json:"string_value,omitempty"`
	Int32Value  *wrapperspb.Int32Value  `protobuf:"bytes,2,opt,name=int32_value,json=int32Value,proto3" json:"int32_value,omitempty"`
	Int64Value  *wrapperspb.Int64Value  `protobuf:"bytes,3,opt,name=int64_value,json=int64Value,proto3" json:"int64_value,omitempty"`
	FloatValue  *wrapperspb.FloatValue  `protobuf:"bytes,4,opt,name=float_value,json=floatValue,proto3" json:"float_value,omitempty"`
	DoubleValue *wrapperspb.DoubleValue `protobuf:"bytes,5,opt,name=double_value,json=doubleValue,proto3" json:"double_value,omitempty"`
	BoolValue   *wrapperspb.BoolValue   `protobuf:"bytes,6,opt,name=bool_value,json=boolValue,proto3" json:"bool_value,omitempty"`
	Uint32Value *wrapperspb.UInt32Value `protobuf:"bytes,7,opt,name=uint32_value,json=uint32Value,proto3" json:"uint32_value,omitempty"`
	Uint64Value *wrapperspb.UInt64Value `protobuf:"bytes,8,opt,name=uint64_value,json=uint64Value,proto3" json:"uint64_value,omitempty"`
	BytesValue  *wrapperspb.BytesValue  `protobuf:"bytes,9,opt,name=bytes_value,json=bytesValue,proto3" json:"bytes_value,omitempty"`
	// contains filtered or unexported fields
}

func (*Wrappers) Descriptor deprecated

func (*Wrappers) Descriptor() ([]byte, []int)

Deprecated: Use Wrappers.ProtoReflect.Descriptor instead.

func (*Wrappers) GetBoolValue

func (x *Wrappers) GetBoolValue() *wrapperspb.BoolValue

func (*Wrappers) GetBytesValue

func (x *Wrappers) GetBytesValue() *wrapperspb.BytesValue

func (*Wrappers) GetDoubleValue

func (x *Wrappers) GetDoubleValue() *wrapperspb.DoubleValue

func (*Wrappers) GetFloatValue

func (x *Wrappers) GetFloatValue() *wrapperspb.FloatValue

func (*Wrappers) GetInt32Value

func (x *Wrappers) GetInt32Value() *wrapperspb.Int32Value

func (*Wrappers) GetInt64Value

func (x *Wrappers) GetInt64Value() *wrapperspb.Int64Value

func (*Wrappers) GetStringValue

func (x *Wrappers) GetStringValue() *wrapperspb.StringValue

func (*Wrappers) GetUint32Value

func (x *Wrappers) GetUint32Value() *wrapperspb.UInt32Value

func (*Wrappers) GetUint64Value

func (x *Wrappers) GetUint64Value() *wrapperspb.UInt64Value

func (*Wrappers) ProtoMessage

func (*Wrappers) ProtoMessage()

func (*Wrappers) ProtoReflect

func (x *Wrappers) ProtoReflect() protoreflect.Message

func (*Wrappers) Reset

func (x *Wrappers) Reset()

func (*Wrappers) String

func (x *Wrappers) String() string

type WrappersServiceClient

type WrappersServiceClient interface {
	Create(ctx context.Context, in *Wrappers, opts ...grpc.CallOption) (*Wrappers, error)
	CreateStringValue(ctx context.Context, in *wrapperspb.StringValue, opts ...grpc.CallOption) (*wrapperspb.StringValue, error)
	CreateInt32Value(ctx context.Context, in *wrapperspb.Int32Value, opts ...grpc.CallOption) (*wrapperspb.Int32Value, error)
	CreateInt64Value(ctx context.Context, in *wrapperspb.Int64Value, opts ...grpc.CallOption) (*wrapperspb.Int64Value, error)
	CreateFloatValue(ctx context.Context, in *wrapperspb.FloatValue, opts ...grpc.CallOption) (*wrapperspb.FloatValue, error)
	CreateDoubleValue(ctx context.Context, in *wrapperspb.DoubleValue, opts ...grpc.CallOption) (*wrapperspb.DoubleValue, error)
	CreateBoolValue(ctx context.Context, in *wrapperspb.BoolValue, opts ...grpc.CallOption) (*wrapperspb.BoolValue, error)
	CreateUInt32Value(ctx context.Context, in *wrapperspb.UInt32Value, opts ...grpc.CallOption) (*wrapperspb.UInt32Value, error)
	CreateUInt64Value(ctx context.Context, in *wrapperspb.UInt64Value, opts ...grpc.CallOption) (*wrapperspb.UInt64Value, error)
	CreateBytesValue(ctx context.Context, in *wrapperspb.BytesValue, opts ...grpc.CallOption) (*wrapperspb.BytesValue, error)
	CreateEmpty(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

WrappersServiceClient is the client API for WrappersService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

type WrappersServiceServer

WrappersServiceServer is the server API for WrappersService service. All implementations should embed UnimplementedWrappersServiceServer for forward compatibility

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL