examplepb

package
v2.14.0 Latest Latest
Warning

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

 Go to latest Published: Nov 5, 2022 License: BSD-3-Clause Imports: 30 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.

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 (
	SnakeCaseEnum_name = map[int32]string{
		0: "value_c",
		1: "value_d",
	}
	SnakeCaseEnum_value = map[string]int32{
		"value_c": 0,
		"value_d": 1,
	}
)

Enum value maps for SnakeCaseEnum.

View Source 
var (
	SnakeCase_0Enum_name = map[int32]string{
		0: "value_e",
		1: "value_f",
	}
	SnakeCase_0Enum_value = map[string]int32{
		"value_e": 0,
		"value_f": 1,
	}
)

Enum value maps for SnakeCase_0Enum.

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 (
	VisibilityRuleEnumInPreviewMethod_name = map[int32]string{
		0: "VISIBILITY_RULE_ENUM_IN_PREVIEW_METHOD_UNSPECIFIED",
	}
	VisibilityRuleEnumInPreviewMethod_value = map[string]int32{
		"VISIBILITY_RULE_ENUM_IN_PREVIEW_METHOD_UNSPECIFIED": 0,
	}
)

Enum value maps for VisibilityRuleEnumInPreviewMethod.

View Source 
var (
	VisibilityRuleSimpleMessage_VisibilityEnum_name = map[int32]string{
		0: "VISIBILITY_ENUM_UNSPECIFIED",
		1: "VISIBILITY_ENUM_VISIBLE",
		2: "VISIBILITY_ENUM_INTERNAL",
		3: "VISIBILITY_ENUM_PREVIEW",
	}
	VisibilityRuleSimpleMessage_VisibilityEnum_value = map[string]int32{
		"VISIBILITY_ENUM_UNSPECIFIED": 0,
		"VISIBILITY_ENUM_VISIBLE":     1,
		"VISIBILITY_ENUM_INTERNAL":    2,
		"VISIBILITY_ENUM_PREVIEW":     3,
	}
)

Enum value maps for VisibilityRuleSimpleMessage_VisibilityEnum.

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: "Custom",
			Handler:    _ABitOfEverythingService_Custom_Handler,
		},
		{
			MethodName: "DoubleColon",
			Handler:    _ABitOfEverythingService_DoubleColon_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,
		},
		{
			MethodName: "Exists",
			Handler:    _ABitOfEverythingService_Exists_Handler,
		},
		{
			MethodName: "CustomOptionsRequest",
			Handler:    _ABitOfEverythingService_CustomOptionsRequest_Handler,
		},
		{
			MethodName: "TraceRequest",
			Handler:    _ABitOfEverythingService_TraceRequest_Handler,
		},
		{
			MethodName: "PostOneofEnum",
			Handler:    _ABitOfEverythingService_PostOneofEnum_Handler,
		},
		{
			MethodName: "PostRequiredMessageType",
			Handler:    _ABitOfEverythingService_PostRequiredMessageType_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_visibility_rule_echo_service_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 SnakeEnumService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.SnakeEnumService",
	HandlerType: (*SnakeEnumServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SnakeEnum",
			Handler:    _SnakeEnumService_SnakeEnum_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/a_bit_of_everything.proto",
}

SnakeEnumService_ServiceDesc is the grpc.ServiceDesc for SnakeEnumService 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 VisibilityRuleEchoService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleEchoService",
	HandlerType: (*VisibilityRuleEchoServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Echo",
			Handler:    _VisibilityRuleEchoService_Echo_Handler,
		},
		{
			MethodName: "EchoInternal",
			Handler:    _VisibilityRuleEchoService_EchoInternal_Handler,
		},
		{
			MethodName: "EchoPreview",
			Handler:    _VisibilityRuleEchoService_EchoPreview_Handler,
		},
		{
			MethodName: "EchoInternalAndPreview",
			Handler:    _VisibilityRuleEchoService_EchoInternalAndPreview_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/visibility_rule_echo_service.proto",
}

VisibilityRuleEchoService_ServiceDesc is the grpc.ServiceDesc for VisibilityRuleEchoService 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 VisibilityRuleInternalEchoService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleInternalEchoService",
	HandlerType: (*VisibilityRuleInternalEchoServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Echo",
			Handler:    _VisibilityRuleInternalEchoService_Echo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/visibility_rule_echo_service.proto",
}

VisibilityRuleInternalEchoService_ServiceDesc is the grpc.ServiceDesc for VisibilityRuleInternalEchoService 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 RegisterSnakeEnumServiceHandler 

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

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

func RegisterSnakeEnumServiceHandlerClient 

func RegisterSnakeEnumServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SnakeEnumServiceClient) error

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

func RegisterSnakeEnumServiceHandlerFromEndpoint 

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

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

func RegisterSnakeEnumServiceHandlerServer 

func RegisterSnakeEnumServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SnakeEnumServiceServer) error

RegisterSnakeEnumServiceHandlerServer registers the http handlers for service SnakeEnumService to "mux". UnaryRPC :call SnakeEnumServiceServer 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 RegisterSnakeEnumServiceHandlerFromEndpoint instead.

func RegisterSnakeEnumServiceServer 

func RegisterSnakeEnumServiceServer(s grpc.ServiceRegistrar, srv SnakeEnumServiceServer)

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 RegisterVisibilityRuleEchoServiceHandler 

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

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

func RegisterVisibilityRuleEchoServiceHandlerClient 

func RegisterVisibilityRuleEchoServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client VisibilityRuleEchoServiceClient) error

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

func RegisterVisibilityRuleEchoServiceHandlerFromEndpoint 

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

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

func RegisterVisibilityRuleEchoServiceHandlerServer 

func RegisterVisibilityRuleEchoServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server VisibilityRuleEchoServiceServer) error

RegisterVisibilityRuleEchoServiceHandlerServer registers the http handlers for service VisibilityRuleEchoService to "mux". UnaryRPC :call VisibilityRuleEchoServiceServer 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 RegisterVisibilityRuleEchoServiceHandlerFromEndpoint instead.

func RegisterVisibilityRuleEchoServiceServer 

func RegisterVisibilityRuleEchoServiceServer(s grpc.ServiceRegistrar, srv VisibilityRuleEchoServiceServer)

func RegisterVisibilityRuleInternalEchoServiceHandler 

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

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

func RegisterVisibilityRuleInternalEchoServiceHandlerClient 

func RegisterVisibilityRuleInternalEchoServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client VisibilityRuleInternalEchoServiceClient) error

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

func RegisterVisibilityRuleInternalEchoServiceHandlerFromEndpoint 

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

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

func RegisterVisibilityRuleInternalEchoServiceHandlerServer 

func RegisterVisibilityRuleInternalEchoServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server VisibilityRuleInternalEchoServiceServer) error

RegisterVisibilityRuleInternalEchoServiceHandlerServer registers the http handlers for service VisibilityRuleInternalEchoService to "mux". UnaryRPC :call VisibilityRuleInternalEchoServiceServer 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 RegisterVisibilityRuleInternalEchoServiceHandlerFromEndpoint instead.

func RegisterVisibilityRuleInternalEchoServiceServer 

func RegisterVisibilityRuleInternalEchoServiceServer(s grpc.ServiceRegistrar, srv VisibilityRuleInternalEchoServiceServer)

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 */
	// Test openapiv2 generation of repeated fields
	ProductId []string `protobuf:"bytes,41,rep,name=product_id,json=productId,proto3" json:"product_id,omitempty"`
	// Test openapiv2 generation of required fields with annotation and jsonschema to reproduce
	OptionalStringField   string `protobuf:"bytes,42,opt,name=optional_string_field,json=optionalStringField,proto3" json:"optional_string_field,omitempty"`
	RequiredStringField_1 string `` /* 126-byte string literal not displayed */
	RequiredStringField_2 string `` /* 126-byte string literal not displayed */
	// Test openapiv2 handling of required json_name fields
	RequiredFieldBehaviorJsonName string ``                                                                                                              /* 166-byte string literal not displayed */
	RequiredFieldSchemaJsonName   string ``                                                                                                              /* 160-byte string literal not displayed */
	TrailingOnly                  string `protobuf:"bytes,47,opt,name=trailing_only,json=trailingOnly,proto3" json:"trailing_only,omitempty"`            // Trailing only
	TrailingOnlyDot               string `protobuf:"bytes,48,opt,name=trailing_only_dot,json=trailingOnlyDot,proto3" json:"trailing_only_dot,omitempty"` // Trailing only dot.
	// Leading both
	TrailingBoth string `protobuf:"bytes,49,opt,name=trailing_both,json=trailingBoth,proto3" json:"trailing_both,omitempty"` // Trailing both.
	// Leading multiline
	//
	// This is an example of a multi-line comment.
	TrailingMultiline string `protobuf:"bytes,50,opt,name=trailing_multiline,json=trailingMultiline,proto3" json:"trailing_multiline,omitempty"` // Trailing multiline.
	// 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) GetOptionalStringField 

func (x *ABitOfEverything) GetOptionalStringField() string

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) GetProductId 

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

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) GetRequiredFieldBehaviorJsonName 

func (x *ABitOfEverything) GetRequiredFieldBehaviorJsonName() string

func (*ABitOfEverything) GetRequiredFieldSchemaJsonName 

func (x *ABitOfEverything) GetRequiredFieldSchemaJsonName() string

func (*ABitOfEverything) GetRequiredStringField_1 

func (x *ABitOfEverything) GetRequiredStringField_1() string

func (*ABitOfEverything) GetRequiredStringField_2 

func (x *ABitOfEverything) GetRequiredStringField_2() 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) GetTrailingBoth 

func (x *ABitOfEverything) GetTrailingBoth() string

func (*ABitOfEverything) GetTrailingMultiline 

func (x *ABitOfEverything) GetTrailingMultiline() string

func (*ABitOfEverything) GetTrailingOnly 

func (x *ABitOfEverything) GetTrailingOnly() string

func (*ABitOfEverything) GetTrailingOnlyDot 

func (x *ABitOfEverything) GetTrailingOnlyDot() string

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)
	Custom(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*ABitOfEverything, error)
	DoubleColon(ctx context.Context, in *ABitOfEverything, 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)
	Exists(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CustomOptionsRequest(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*emptypb.Empty, error)
	TraceRequest(ctx context.Context, in *ABitOfEverything, opts ...grpc.CallOption) (*ABitOfEverything, error)
	PostOneofEnum(ctx context.Context, in *oneofenum.OneofEnumMessage, opts ...grpc.CallOption) (*emptypb.Empty, error)
	PostRequiredMessageType(ctx context.Context, in *RequiredMessageTypeRequest, opts ...grpc.CallOption) (*emptypb.Empty, 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.

func NewABitOfEverythingServiceClient 

func NewABitOfEverythingServiceClient(cc grpc.ClientConnInterface) ABitOfEverythingServiceClient

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)
	Custom(context.Context, *ABitOfEverything) (*ABitOfEverything, error)
	DoubleColon(context.Context, *ABitOfEverything) (*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)
	Exists(context.Context, *ABitOfEverything) (*emptypb.Empty, error)
	CustomOptionsRequest(context.Context, *ABitOfEverything) (*emptypb.Empty, error)
	TraceRequest(context.Context, *ABitOfEverything) (*ABitOfEverything, error)
	PostOneofEnum(context.Context, *oneofenum.OneofEnumMessage) (*emptypb.Empty, error)
	PostRequiredMessageType(context.Context, *RequiredMessageTypeRequest) (*emptypb.Empty, 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 (x *ABitOfEverything_Nested) GetOk() ABitOfEverything_Nested_DeepEnum

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) Descriptor() protoreflect.EnumDescriptor

func (ABitOfEverything_Nested_DeepEnum) Enum 

func (x ABitOfEverything_Nested_DeepEnum) Enum() *ABitOfEverything_Nested_DeepEnum

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 (x ABitOfEverything_Nested_DeepEnum) Number() protoreflect.EnumNumber

func (ABitOfEverything_Nested_DeepEnum) String 

func (x ABitOfEverything_Nested_DeepEnum) String() string

func (ABitOfEverything_Nested_DeepEnum) Type 

func (ABitOfEverything_Nested_DeepEnum) Type() protoreflect.EnumType

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.

func NewAnotherServiceWithNoBindingsClient 

func NewAnotherServiceWithNoBindingsClient(cc grpc.ClientConnInterface) AnotherServiceWithNoBindingsClient

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 Bar 

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

func (*Bar) Descriptor deprecated 

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

Deprecated: Use Bar.ProtoReflect.Descriptor instead.

func (*Bar) GetId 

func (x *Bar) GetId() string

func (*Bar) ProtoMessage 

func (*Bar) ProtoMessage()

func (*Bar) ProtoReflect 

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

func (*Bar) Reset 

func (x *Bar) Reset()

func (*Bar) String 

func (x *Bar) String() string

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.

func NewCamelCaseServiceNameClient 

func NewCamelCaseServiceNameClient(cc grpc.ClientConnInterface) CamelCaseServiceNameClient

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.

func NewEchoServiceClient 

func NewEchoServiceClient(cc grpc.ClientConnInterface) EchoServiceClient

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.

func NewFlowCombinationClient 

func NewFlowCombinationClient(cc grpc.ClientConnInterface) FlowCombinationClient

type FlowCombinationServer 

type FlowCombinationServer interface {
	RpcEmptyRpc(context.Context, *EmptyProto) (*EmptyProto, error)
	RpcEmptyStream(*EmptyProto, FlowCombination_RpcEmptyStreamServer) error
	StreamEmptyRpc(FlowCombination_StreamEmptyRpcServer) error
	StreamEmptyStream(FlowCombination_StreamEmptyStreamServer) error
	RpcBodyRpc(context.Context, *NonEmptyProto) (*EmptyProto, error)
	RpcPathSingleNestedRpc(context.Context, *SingleNestedProto) (*EmptyProto, error)
	RpcPathNestedRpc(context.Context, *NestedProto) (*EmptyProto, error)
	RpcBodyStream(*NonEmptyProto, FlowCombination_RpcBodyStreamServer) error
	RpcPathSingleNestedStream(*SingleNestedProto, FlowCombination_RpcPathSingleNestedStreamServer) error
	RpcPathNestedStream(*NestedProto, FlowCombination_RpcPathNestedStreamServer) error
}

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 Foo 

type Foo struct {
	Bar *Bar `protobuf:"bytes,1,opt,name=bar,proto3" json:"bar,omitempty"`
	// contains filtered or unexported fields
}

func (*Foo) Descriptor deprecated 

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

Deprecated: Use Foo.ProtoReflect.Descriptor instead.

func (*Foo) GetBar 

func (x *Foo) GetBar() *Bar

func (*Foo) ProtoMessage 

func (*Foo) ProtoMessage()

func (*Foo) ProtoReflect 

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

func (*Foo) Reset 

func (x *Foo) Reset()

func (*Foo) String 

func (x *Foo) String() string

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.

func NewGenerateUnboundMethodsEchoServiceClient 

func NewGenerateUnboundMethodsEchoServiceClient(cc grpc.ClientConnInterface) GenerateUnboundMethodsEchoServiceClient

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 (x *GenerateUnboundMethodsSimpleMessage) GetDuration() *durationpb.Duration

func (*GenerateUnboundMethodsSimpleMessage) GetId 

func (x *GenerateUnboundMethodsSimpleMessage) GetId() string

func (*GenerateUnboundMethodsSimpleMessage) GetNum 

func (x *GenerateUnboundMethodsSimpleMessage) GetNum() int64

func (*GenerateUnboundMethodsSimpleMessage) ProtoMessage 

func (*GenerateUnboundMethodsSimpleMessage) ProtoMessage()

func (*GenerateUnboundMethodsSimpleMessage) ProtoReflect 

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

func (*GenerateUnboundMethodsSimpleMessage) Reset 

func (x *GenerateUnboundMethodsSimpleMessage) Reset()

func (*GenerateUnboundMethodsSimpleMessage) String 

func (x *GenerateUnboundMethodsSimpleMessage) String() 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.

func NewLoginServiceClient 

func NewLoginServiceClient(cc grpc.ClientConnInterface) LoginServiceClient

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 (x *NonStandardMessage) GetThing() *NonStandardMessage_Thing

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 (x *NonStandardMessageWithJSONNames) GetId() string

func (*NonStandardMessageWithJSONNames) GetLangIdent 

func (x *NonStandardMessageWithJSONNames) GetLangIdent() string

func (*NonStandardMessageWithJSONNames) GetLineNum 

func (x *NonStandardMessageWithJSONNames) GetLineNum() int64

func (*NonStandardMessageWithJSONNames) GetNo 

func (x *NonStandardMessageWithJSONNames) GetNo() string

func (*NonStandardMessageWithJSONNames) GetNum 

func (x *NonStandardMessageWithJSONNames) GetNum() int64

func (*NonStandardMessageWithJSONNames) GetSTATUS 

func (x *NonStandardMessageWithJSONNames) GetSTATUS() string

func (*NonStandardMessageWithJSONNames) GetThing 

func (x *NonStandardMessageWithJSONNames) GetThing() *NonStandardMessageWithJSONNames_Thing

func (*NonStandardMessageWithJSONNames) ProtoMessage 

func (*NonStandardMessageWithJSONNames) ProtoMessage()

func (*NonStandardMessageWithJSONNames) ProtoReflect 

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

func (*NonStandardMessageWithJSONNames) Reset 

func (x *NonStandardMessageWithJSONNames) Reset()

func (*NonStandardMessageWithJSONNames) String 

func (x *NonStandardMessageWithJSONNames) String() 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 (x *NonStandardMessageWithJSONNames_Thing) GetSubThing() *NonStandardMessageWithJSONNames_Thing_SubThing

func (*NonStandardMessageWithJSONNames_Thing) ProtoMessage 

func (*NonStandardMessageWithJSONNames_Thing) ProtoMessage()

func (*NonStandardMessageWithJSONNames_Thing) ProtoReflect 

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

func (*NonStandardMessageWithJSONNames_Thing) Reset 

func (x *NonStandardMessageWithJSONNames_Thing) Reset()

func (*NonStandardMessageWithJSONNames_Thing) String 

func (x *NonStandardMessageWithJSONNames_Thing) String() 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 

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

Deprecated: Use NonStandardMessageWithJSONNames_Thing_SubThing.ProtoReflect.Descriptor instead.

func (*NonStandardMessageWithJSONNames_Thing_SubThing) GetSubValue 

func (x *NonStandardMessageWithJSONNames_Thing_SubThing) GetSubValue() string

func (*NonStandardMessageWithJSONNames_Thing_SubThing) ProtoMessage 

func (*NonStandardMessageWithJSONNames_Thing_SubThing) ProtoMessage()

func (*NonStandardMessageWithJSONNames_Thing_SubThing) ProtoReflect 

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

func (*NonStandardMessageWithJSONNames_Thing_SubThing) Reset 

func (x *NonStandardMessageWithJSONNames_Thing_SubThing) Reset()

func (*NonStandardMessageWithJSONNames_Thing_SubThing) String 

func (x *NonStandardMessageWithJSONNames_Thing_SubThing) String() 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 (x *NonStandardMessage_Thing) GetSubThing() *NonStandardMessage_Thing_SubThing

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 (x *NonStandardMessage_Thing_SubThing) ProtoReflect() protoreflect.Message

func (*NonStandardMessage_Thing_SubThing) Reset 

func (x *NonStandardMessage_Thing_SubThing) Reset()

func (*NonStandardMessage_Thing_SubThing) String 

func (x *NonStandardMessage_Thing_SubThing) String() 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.

func NewNonStandardServiceClient 

func NewNonStandardServiceClient(cc grpc.ClientConnInterface) NonStandardServiceClient

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 (x *NonStandardUpdateRequest) GetBody() *NonStandardMessage

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 (x *NonStandardWithJSONNamesUpdateRequest) GetBody() *NonStandardMessageWithJSONNames

func (*NonStandardWithJSONNamesUpdateRequest) GetUpdateMask 

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

func (*NonStandardWithJSONNamesUpdateRequest) ProtoMessage 

func (*NonStandardWithJSONNamesUpdateRequest) ProtoMessage()

func (*NonStandardWithJSONNamesUpdateRequest) ProtoReflect 

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

func (*NonStandardWithJSONNamesUpdateRequest) Reset 

func (x *NonStandardWithJSONNamesUpdateRequest) Reset()

func (*NonStandardWithJSONNamesUpdateRequest) String 

func (x *NonStandardWithJSONNamesUpdateRequest) String() 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) Descriptor() protoreflect.EnumDescriptor

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 

func (NumericEnum) Type() protoreflect.EnumType

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 (x *RepeatedResponseBodyOut) GetResponse() []*RepeatedResponseBodyOut_Response

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 (x *RepeatedResponseBodyOut_Response) GetData() string

func (*RepeatedResponseBodyOut_Response) GetType 

func (x *RepeatedResponseBodyOut_Response) GetType() RepeatedResponseBodyOut_Response_ResponseType

func (*RepeatedResponseBodyOut_Response) ProtoMessage 

func (*RepeatedResponseBodyOut_Response) ProtoMessage()

func (*RepeatedResponseBodyOut_Response) ProtoReflect 

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

func (*RepeatedResponseBodyOut_Response) Reset 

func (x *RepeatedResponseBodyOut_Response) Reset()

func (*RepeatedResponseBodyOut_Response) String 

func (x *RepeatedResponseBodyOut_Response) String() 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) Descriptor() protoreflect.EnumDescriptor

func (RepeatedResponseBodyOut_Response_ResponseType) Enum 

func (x RepeatedResponseBodyOut_Response_ResponseType) Enum() *RepeatedResponseBodyOut_Response_ResponseType

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 (x RepeatedResponseBodyOut_Response_ResponseType) Number() protoreflect.EnumNumber

func (RepeatedResponseBodyOut_Response_ResponseType) String 

func (x RepeatedResponseBodyOut_Response_ResponseType) String() string

func (RepeatedResponseBodyOut_Response_ResponseType) Type 

func (RepeatedResponseBodyOut_Response_ResponseType) Type() protoreflect.EnumType

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 RequiredMessageTypeRequest 

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

Required message type -> OpenAPI https://github.com/grpc-ecosystem/grpc-gateway/issues/2837

func (*RequiredMessageTypeRequest) Descriptor deprecated 

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

Deprecated: Use RequiredMessageTypeRequest.ProtoReflect.Descriptor instead.

func (*RequiredMessageTypeRequest) GetFoo 

func (x *RequiredMessageTypeRequest) GetFoo() *Foo

func (*RequiredMessageTypeRequest) GetId 

func (x *RequiredMessageTypeRequest) GetId() string

func (*RequiredMessageTypeRequest) ProtoMessage 

func (*RequiredMessageTypeRequest) ProtoMessage()

func (*RequiredMessageTypeRequest) ProtoReflect 

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

func (*RequiredMessageTypeRequest) Reset 

func (x *RequiredMessageTypeRequest) Reset()

func (*RequiredMessageTypeRequest) String 

func (x *RequiredMessageTypeRequest) 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.

func NewResponseBodyServiceClient 

func NewResponseBodyServiceClient(cc grpc.ClientConnInterface) ResponseBodyServiceClient

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 SnakeCaseEnum 

type SnakeCaseEnum int32

Ignoring lint warnings as this enum type exist to validate proper functionality for projects that don't follow these lint rules. buf:lint:ignore ENUM_PASCAL_CASE 

const (
	// buf:lint:ignore ENUM_VALUE_UPPER_SNAKE_CASE
	SnakeCaseEnum_value_c SnakeCaseEnum = 0
	// buf:lint:ignore ENUM_VALUE_UPPER_SNAKE_CASE
	SnakeCaseEnum_value_d SnakeCaseEnum = 1
)

func (SnakeCaseEnum) Descriptor 

func (SnakeCaseEnum) Descriptor() protoreflect.EnumDescriptor

func (SnakeCaseEnum) Enum 

func (x SnakeCaseEnum) Enum() *SnakeCaseEnum

func (SnakeCaseEnum) EnumDescriptor deprecated 

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

Deprecated: Use SnakeCaseEnum.Descriptor instead.

func (SnakeCaseEnum) Number 

func (x SnakeCaseEnum) Number() protoreflect.EnumNumber

func (SnakeCaseEnum) String 

func (x SnakeCaseEnum) String() string

func (SnakeCaseEnum) Type 

func (SnakeCaseEnum) Type() protoreflect.EnumType

type SnakeCase_0Enum 

type SnakeCase_0Enum int32

Ignoring lint warnings as this enum type exist to validate proper functionality for projects that don't follow these lint rules. buf:lint:ignore ENUM_PASCAL_CASE 

const (
	// buf:lint:ignore ENUM_VALUE_UPPER_SNAKE_CASE
	SnakeCase_0Enum_value_e SnakeCase_0Enum = 0
	// buf:lint:ignore ENUM_VALUE_UPPER_SNAKE_CASE
	SnakeCase_0Enum_value_f SnakeCase_0Enum = 1
)

func (SnakeCase_0Enum) Descriptor 

func (SnakeCase_0Enum) Descriptor() protoreflect.EnumDescriptor

func (SnakeCase_0Enum) Enum 

func (x SnakeCase_0Enum) Enum() *SnakeCase_0Enum

func (SnakeCase_0Enum) EnumDescriptor deprecated 

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

Deprecated: Use SnakeCase_0Enum.Descriptor instead.

func (SnakeCase_0Enum) Number 

func (x SnakeCase_0Enum) Number() protoreflect.EnumNumber

func (SnakeCase_0Enum) String 

func (x SnakeCase_0Enum) String() string

func (SnakeCase_0Enum) Type 

func (SnakeCase_0Enum) Type() protoreflect.EnumType

type SnakeEnumRequest 

type SnakeEnumRequest struct {
	What  SnakeCaseEnum               `` /* 128-byte string literal not displayed */
	Who   SnakeCase_0Enum             `` /* 128-byte string literal not displayed */
	Where pathenum.SnakeCaseForImport `` /* 128-byte string literal not displayed */
	// contains filtered or unexported fields
}

func (*SnakeEnumRequest) Descriptor deprecated 

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

Deprecated: Use SnakeEnumRequest.ProtoReflect.Descriptor instead.

func (*SnakeEnumRequest) GetWhat 

func (x *SnakeEnumRequest) GetWhat() SnakeCaseEnum

func (*SnakeEnumRequest) GetWhere 

func (x *SnakeEnumRequest) GetWhere() pathenum.SnakeCaseForImport

func (*SnakeEnumRequest) GetWho 

func (x *SnakeEnumRequest) GetWho() SnakeCase_0Enum

func (*SnakeEnumRequest) ProtoMessage 

func (*SnakeEnumRequest) ProtoMessage()

func (*SnakeEnumRequest) ProtoReflect 

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

func (*SnakeEnumRequest) Reset 

func (x *SnakeEnumRequest) Reset()

func (*SnakeEnumRequest) String 

func (x *SnakeEnumRequest) String() string

type SnakeEnumResponse 

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

func (*SnakeEnumResponse) Descriptor deprecated 

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

Deprecated: Use SnakeEnumResponse.ProtoReflect.Descriptor instead.

func (*SnakeEnumResponse) ProtoMessage 

func (*SnakeEnumResponse) ProtoMessage()

func (*SnakeEnumResponse) ProtoReflect 

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

func (*SnakeEnumResponse) Reset 

func (x *SnakeEnumResponse) Reset()

func (*SnakeEnumResponse) String 

func (x *SnakeEnumResponse) String() string

type SnakeEnumServiceClient 

type SnakeEnumServiceClient interface {
	SnakeEnum(ctx context.Context, in *SnakeEnumRequest, opts ...grpc.CallOption) (*SnakeEnumResponse, error)
}

SnakeEnumServiceClient is the client API for SnakeEnumService 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 NewSnakeEnumServiceClient 

func NewSnakeEnumServiceClient(cc grpc.ClientConnInterface) SnakeEnumServiceClient

type SnakeEnumServiceServer 

type SnakeEnumServiceServer interface {
	SnakeEnum(context.Context, *SnakeEnumRequest) (*SnakeEnumResponse, error)
}

SnakeEnumServiceServer is the server API for SnakeEnumService service. All implementations should embed UnimplementedSnakeEnumServiceServer for forward compatibility

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.

func NewStreamServiceClient 

func NewStreamServiceClient(cc grpc.ClientConnInterface) StreamServiceClient

type StreamServiceServer 

type StreamServiceServer interface {
	BulkCreate(StreamService_BulkCreateServer) error
	List(*emptypb.Empty, StreamService_ListServer) error
	BulkEcho(StreamService_BulkEchoServer) error
	Download(*emptypb.Empty, StreamService_DownloadServer) error
}

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.

func NewUnannotatedEchoServiceClient 

func NewUnannotatedEchoServiceClient(cc grpc.ClientConnInterface) UnannotatedEchoServiceClient

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 (x *UnannotatedSimpleMessage) GetNo() *UnannotatedEmbedded

func (*UnannotatedSimpleMessage) GetNum 

func (x *UnannotatedSimpleMessage) GetNum() int64

func (*UnannotatedSimpleMessage) GetStatus 

func (x *UnannotatedSimpleMessage) GetStatus() *UnannotatedEmbedded

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) CheckExternalNestedPathEnum(context.Context, *pathenum.MessageWithNestedPathEnum) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) CheckExternalPathEnum 

func (UnimplementedABitOfEverythingServiceServer) CheckExternalPathEnum(context.Context, *pathenum.MessageWithPathEnum) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) CheckGetQueryParams 

func (UnimplementedABitOfEverythingServiceServer) CheckGetQueryParams(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) CheckNestedEnumGetQueryParams 

func (UnimplementedABitOfEverythingServiceServer) CheckNestedEnumGetQueryParams(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) CheckPostQueryParams 

func (UnimplementedABitOfEverythingServiceServer) CheckPostQueryParams(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) CheckStatus 

func (UnimplementedABitOfEverythingServiceServer) CheckStatus(context.Context, *emptypb.Empty) (*CheckStatusResponse, error)

func (UnimplementedABitOfEverythingServiceServer) Create 

func (UnimplementedABitOfEverythingServiceServer) Create(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) CreateBody 

func (UnimplementedABitOfEverythingServiceServer) CreateBody(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) CreateBook 

func (UnimplementedABitOfEverythingServiceServer) CreateBook(context.Context, *CreateBookRequest) (*Book, error)

func (UnimplementedABitOfEverythingServiceServer) Custom 

func (UnimplementedABitOfEverythingServiceServer) Custom(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) CustomOptionsRequest 

func (UnimplementedABitOfEverythingServiceServer) CustomOptionsRequest(context.Context, *ABitOfEverything) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) DeepPathEcho 

func (UnimplementedABitOfEverythingServiceServer) DeepPathEcho(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) Delete 

func (UnimplementedABitOfEverythingServiceServer) Delete(context.Context, *sub2.IdMessage) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) DoubleColon 

func (UnimplementedABitOfEverythingServiceServer) DoubleColon(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) Echo 

func (UnimplementedABitOfEverythingServiceServer) Echo(context.Context, *sub.StringMessage) (*sub.StringMessage, error)

func (UnimplementedABitOfEverythingServiceServer) ErrorWithDetails 

func (UnimplementedABitOfEverythingServiceServer) ErrorWithDetails(context.Context, *emptypb.Empty) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) Exists 

func (UnimplementedABitOfEverythingServiceServer) Exists(context.Context, *ABitOfEverything) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) GetMessageWithBody 

func (UnimplementedABitOfEverythingServiceServer) GetMessageWithBody(context.Context, *MessageWithBody) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) GetQuery 

func (UnimplementedABitOfEverythingServiceServer) GetQuery(context.Context, *ABitOfEverything) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) GetRepeatedQuery 

func (UnimplementedABitOfEverythingServiceServer) GetRepeatedQuery(context.Context, *ABitOfEverythingRepeated) (*ABitOfEverythingRepeated, error)

func (UnimplementedABitOfEverythingServiceServer) Lookup 

func (UnimplementedABitOfEverythingServiceServer) Lookup(context.Context, *sub2.IdMessage) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) NoBindings 

func (UnimplementedABitOfEverythingServiceServer) NoBindings(context.Context, *durationpb.Duration) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) OverwriteResponseContentType 

func (UnimplementedABitOfEverythingServiceServer) OverwriteResponseContentType(context.Context, *emptypb.Empty) (*wrapperspb.StringValue, error)

func (UnimplementedABitOfEverythingServiceServer) PostOneofEnum 

func (UnimplementedABitOfEverythingServiceServer) PostOneofEnum(context.Context, *oneofenum.OneofEnumMessage) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) PostRequiredMessageType 

func (UnimplementedABitOfEverythingServiceServer) PostRequiredMessageType(context.Context, *RequiredMessageTypeRequest) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) PostWithEmptyBody 

func (UnimplementedABitOfEverythingServiceServer) PostWithEmptyBody(context.Context, *Body) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) Timeout 

func (UnimplementedABitOfEverythingServiceServer) Timeout(context.Context, *emptypb.Empty) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) TraceRequest 

func (UnimplementedABitOfEverythingServiceServer) TraceRequest(context.Context, *ABitOfEverything) (*ABitOfEverything, error)

func (UnimplementedABitOfEverythingServiceServer) Update 

func (UnimplementedABitOfEverythingServiceServer) Update(context.Context, *ABitOfEverything) (*emptypb.Empty, error)

func (UnimplementedABitOfEverythingServiceServer) UpdateBook 

func (UnimplementedABitOfEverythingServiceServer) UpdateBook(context.Context, *UpdateBookRequest) (*Book, error)

func (UnimplementedABitOfEverythingServiceServer) UpdateV2 

func (UnimplementedABitOfEverythingServiceServer) UpdateV2(context.Context, *UpdateV2Request) (*emptypb.Empty, error)

type UnimplementedAnotherServiceWithNoBindingsServer 

type UnimplementedAnotherServiceWithNoBindingsServer struct {
}

UnimplementedAnotherServiceWithNoBindingsServer should be embedded to have forward compatible implementations.

func (UnimplementedAnotherServiceWithNoBindingsServer) NoBindings 

func (UnimplementedAnotherServiceWithNoBindingsServer) NoBindings(context.Context, *emptypb.Empty) (*emptypb.Empty, error)

type UnimplementedCamelCaseServiceNameServer 

type UnimplementedCamelCaseServiceNameServer struct {
}

UnimplementedCamelCaseServiceNameServer should be embedded to have forward compatible implementations.

func (UnimplementedCamelCaseServiceNameServer) Empty 

func (UnimplementedCamelCaseServiceNameServer) Empty(context.Context, *emptypb.Empty) (*emptypb.Empty, error)

type UnimplementedEchoServiceServer 

type UnimplementedEchoServiceServer struct {
}

UnimplementedEchoServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedEchoServiceServer) Echo 

func (UnimplementedEchoServiceServer) Echo(context.Context, *SimpleMessage) (*SimpleMessage, error)

func (UnimplementedEchoServiceServer) EchoBody 

func (UnimplementedEchoServiceServer) EchoBody(context.Context, *SimpleMessage) (*SimpleMessage, error)

func (UnimplementedEchoServiceServer) EchoDelete 

func (UnimplementedEchoServiceServer) EchoDelete(context.Context, *SimpleMessage) (*SimpleMessage, error)

func (UnimplementedEchoServiceServer) EchoPatch 

func (UnimplementedEchoServiceServer) EchoPatch(context.Context, *DynamicMessageUpdate) (*DynamicMessageUpdate, error)

func (UnimplementedEchoServiceServer) EchoUnauthorized 

func (UnimplementedEchoServiceServer) EchoUnauthorized(context.Context, *SimpleMessage) (*SimpleMessage, error)

type UnimplementedFlowCombinationServer 

type UnimplementedFlowCombinationServer struct {
}

UnimplementedFlowCombinationServer should be embedded to have forward compatible implementations.

func (UnimplementedFlowCombinationServer) RpcBodyRpc 

func (UnimplementedFlowCombinationServer) RpcBodyRpc(context.Context, *NonEmptyProto) (*EmptyProto, error)

func (UnimplementedFlowCombinationServer) RpcBodyStream 

func (UnimplementedFlowCombinationServer) RpcBodyStream(*NonEmptyProto, FlowCombination_RpcBodyStreamServer) error

func (UnimplementedFlowCombinationServer) RpcEmptyRpc 

func (UnimplementedFlowCombinationServer) RpcEmptyRpc(context.Context, *EmptyProto) (*EmptyProto, error)

func (UnimplementedFlowCombinationServer) RpcEmptyStream 

func (UnimplementedFlowCombinationServer) RpcEmptyStream(*EmptyProto, FlowCombination_RpcEmptyStreamServer) error

func (UnimplementedFlowCombinationServer) RpcPathNestedRpc 

func (UnimplementedFlowCombinationServer) RpcPathNestedRpc(context.Context, *NestedProto) (*EmptyProto, error)

func (UnimplementedFlowCombinationServer) RpcPathNestedStream 

func (UnimplementedFlowCombinationServer) RpcPathNestedStream(*NestedProto, FlowCombination_RpcPathNestedStreamServer) error

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedRpc 

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedRpc(context.Context, *SingleNestedProto) (*EmptyProto, error)

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedStream 

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedStream(*SingleNestedProto, FlowCombination_RpcPathSingleNestedStreamServer) error

func (UnimplementedFlowCombinationServer) StreamEmptyRpc 

func (UnimplementedFlowCombinationServer) StreamEmptyRpc(FlowCombination_StreamEmptyRpcServer) error

func (UnimplementedFlowCombinationServer) StreamEmptyStream 

func (UnimplementedFlowCombinationServer) StreamEmptyStream(FlowCombination_StreamEmptyStreamServer) error

type UnimplementedGenerateUnboundMethodsEchoServiceServer 

type UnimplementedGenerateUnboundMethodsEchoServiceServer struct {
}

UnimplementedGenerateUnboundMethodsEchoServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedGenerateUnboundMethodsEchoServiceServer) Echo 

func (UnimplementedGenerateUnboundMethodsEchoServiceServer) Echo(context.Context, *GenerateUnboundMethodsSimpleMessage) (*GenerateUnboundMethodsSimpleMessage, error)

func (UnimplementedGenerateUnboundMethodsEchoServiceServer) EchoBody 

func (UnimplementedGenerateUnboundMethodsEchoServiceServer) EchoBody(context.Context, *GenerateUnboundMethodsSimpleMessage) (*GenerateUnboundMethodsSimpleMessage, error)

func (UnimplementedGenerateUnboundMethodsEchoServiceServer) EchoDelete 

func (UnimplementedGenerateUnboundMethodsEchoServiceServer) EchoDelete(context.Context, *GenerateUnboundMethodsSimpleMessage) (*GenerateUnboundMethodsSimpleMessage, error)

type UnimplementedLoginServiceServer 

type UnimplementedLoginServiceServer struct {
}

UnimplementedLoginServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedLoginServiceServer) Login 

func (UnimplementedLoginServiceServer) Login(context.Context, *LoginRequest) (*LoginReply, error)

func (UnimplementedLoginServiceServer) Logout 

func (UnimplementedLoginServiceServer) Logout(context.Context, *LogoutRequest) (*LogoutReply, error)

type UnimplementedNonStandardServiceServer 

type UnimplementedNonStandardServiceServer struct {
}

UnimplementedNonStandardServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedNonStandardServiceServer) Update 

func (UnimplementedNonStandardServiceServer) Update(context.Context, *NonStandardUpdateRequest) (*NonStandardMessage, error)

func (UnimplementedNonStandardServiceServer) UpdateWithJSONNames 

func (UnimplementedNonStandardServiceServer) UpdateWithJSONNames(context.Context, *NonStandardWithJSONNamesUpdateRequest) (*NonStandardMessageWithJSONNames, error)

type UnimplementedResponseBodyServiceServer 

type UnimplementedResponseBodyServiceServer struct {
}

UnimplementedResponseBodyServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedResponseBodyServiceServer) GetResponseBody 

func (UnimplementedResponseBodyServiceServer) GetResponseBody(context.Context, *ResponseBodyIn) (*ResponseBodyOut, error)

func (UnimplementedResponseBodyServiceServer) GetResponseBodyStream 

func (UnimplementedResponseBodyServiceServer) GetResponseBodyStream(*ResponseBodyIn, ResponseBodyService_GetResponseBodyStreamServer) error

func (UnimplementedResponseBodyServiceServer) ListResponseBodies 

func (UnimplementedResponseBodyServiceServer) ListResponseBodies(context.Context, *ResponseBodyIn) (*RepeatedResponseBodyOut, error)

func (UnimplementedResponseBodyServiceServer) ListResponseStrings 

func (UnimplementedResponseBodyServiceServer) ListResponseStrings(context.Context, *ResponseBodyIn) (*RepeatedResponseStrings, error)

type UnimplementedServiceAServer 

type UnimplementedServiceAServer struct {
}

UnimplementedServiceAServer should be embedded to have forward compatible implementations.

func (UnimplementedServiceAServer) MethodOne 

func (UnimplementedServiceAServer) MethodOne(context.Context, *InMessageA) (*OutMessageA, error)

func (UnimplementedServiceAServer) MethodTwo 

func (UnimplementedServiceAServer) MethodTwo(context.Context, *OutMessageA) (*InMessageA, error)

type UnimplementedServiceBServer 

type UnimplementedServiceBServer struct {
}

UnimplementedServiceBServer should be embedded to have forward compatible implementations.

func (UnimplementedServiceBServer) MethodOne 

func (UnimplementedServiceBServer) MethodOne(context.Context, *InMessageB) (*OutMessageB, error)

func (UnimplementedServiceBServer) MethodTwo 

func (UnimplementedServiceBServer) MethodTwo(context.Context, *OutMessageB) (*InMessageB, error)

type UnimplementedServiceCServer 

type UnimplementedServiceCServer struct {
}

UnimplementedServiceCServer should be embedded to have forward compatible implementations.

func (UnimplementedServiceCServer) MethodOne 

func (UnimplementedServiceCServer) MethodOne(context.Context, *InMessageA) (*OutMessageC, error)

func (UnimplementedServiceCServer) MethodTwo 

func (UnimplementedServiceCServer) MethodTwo(context.Context, *OutMessageA) (*InMessageA, error)

type UnimplementedSnakeEnumServiceServer 

type UnimplementedSnakeEnumServiceServer struct {
}

UnimplementedSnakeEnumServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedSnakeEnumServiceServer) SnakeEnum 

func (UnimplementedSnakeEnumServiceServer) SnakeEnum(context.Context, *SnakeEnumRequest) (*SnakeEnumResponse, error)

type UnimplementedStreamServiceServer 

type UnimplementedStreamServiceServer struct {
}

UnimplementedStreamServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedStreamServiceServer) BulkCreate 

func (UnimplementedStreamServiceServer) BulkCreate(StreamService_BulkCreateServer) error

func (UnimplementedStreamServiceServer) BulkEcho 

func (UnimplementedStreamServiceServer) BulkEcho(StreamService_BulkEchoServer) error

func (UnimplementedStreamServiceServer) Download 

func (UnimplementedStreamServiceServer) Download(*emptypb.Empty, StreamService_DownloadServer) error

func (UnimplementedStreamServiceServer) List 

func (UnimplementedStreamServiceServer) List(*emptypb.Empty, StreamService_ListServer) error

type UnimplementedUnannotatedEchoServiceServer 

type UnimplementedUnannotatedEchoServiceServer struct {
}

UnimplementedUnannotatedEchoServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedUnannotatedEchoServiceServer) Echo 

func (UnimplementedUnannotatedEchoServiceServer) Echo(context.Context, *UnannotatedSimpleMessage) (*UnannotatedSimpleMessage, error)

func (UnimplementedUnannotatedEchoServiceServer) EchoBody 

func (UnimplementedUnannotatedEchoServiceServer) EchoBody(context.Context, *UnannotatedSimpleMessage) (*UnannotatedSimpleMessage, error)

func (UnimplementedUnannotatedEchoServiceServer) EchoDelete 

func (UnimplementedUnannotatedEchoServiceServer) EchoDelete(context.Context, *UnannotatedSimpleMessage) (*UnannotatedSimpleMessage, error)

type UnimplementedVisibilityRuleEchoServiceServer 

type UnimplementedVisibilityRuleEchoServiceServer struct {
}

UnimplementedVisibilityRuleEchoServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedVisibilityRuleEchoServiceServer) Echo 

func (UnimplementedVisibilityRuleEchoServiceServer) Echo(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleSimpleMessage, error)

func (UnimplementedVisibilityRuleEchoServiceServer) EchoInternal 

func (UnimplementedVisibilityRuleEchoServiceServer) EchoInternal(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleSimpleMessage, error)

func (UnimplementedVisibilityRuleEchoServiceServer) EchoInternalAndPreview 

func (UnimplementedVisibilityRuleEchoServiceServer) EchoInternalAndPreview(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleSimpleMessage, error)

func (UnimplementedVisibilityRuleEchoServiceServer) EchoPreview 

func (UnimplementedVisibilityRuleEchoServiceServer) EchoPreview(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleMessageInPreviewMethod, error)

type UnimplementedVisibilityRuleInternalEchoServiceServer 

type UnimplementedVisibilityRuleInternalEchoServiceServer struct {
}

UnimplementedVisibilityRuleInternalEchoServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedVisibilityRuleInternalEchoServiceServer) Echo 

func (UnimplementedVisibilityRuleInternalEchoServiceServer) Echo(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleSimpleMessage, error)

type UnimplementedWrappersServiceServer 

type UnimplementedWrappersServiceServer struct {
}

UnimplementedWrappersServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedWrappersServiceServer) Create 

func (UnimplementedWrappersServiceServer) Create(context.Context, *Wrappers) (*Wrappers, error)

func (UnimplementedWrappersServiceServer) CreateBoolValue 

func (UnimplementedWrappersServiceServer) CreateBoolValue(context.Context, *wrapperspb.BoolValue) (*wrapperspb.BoolValue, error)

func (UnimplementedWrappersServiceServer) CreateBytesValue 

func (UnimplementedWrappersServiceServer) CreateBytesValue(context.Context, *wrapperspb.BytesValue) (*wrapperspb.BytesValue, error)

func (UnimplementedWrappersServiceServer) CreateDoubleValue 

func (UnimplementedWrappersServiceServer) CreateDoubleValue(context.Context, *wrapperspb.DoubleValue) (*wrapperspb.DoubleValue, error)

func (UnimplementedWrappersServiceServer) CreateEmpty 

func (UnimplementedWrappersServiceServer) CreateEmpty(context.Context, *emptypb.Empty) (*emptypb.Empty, error)

func (UnimplementedWrappersServiceServer) CreateFloatValue 

func (UnimplementedWrappersServiceServer) CreateFloatValue(context.Context, *wrapperspb.FloatValue) (*wrapperspb.FloatValue, error)

func (UnimplementedWrappersServiceServer) CreateInt32Value 

func (UnimplementedWrappersServiceServer) CreateInt32Value(context.Context, *wrapperspb.Int32Value) (*wrapperspb.Int32Value, error)

func (UnimplementedWrappersServiceServer) CreateInt64Value 

func (UnimplementedWrappersServiceServer) CreateInt64Value(context.Context, *wrapperspb.Int64Value) (*wrapperspb.Int64Value, error)

func (UnimplementedWrappersServiceServer) CreateStringValue 

func (UnimplementedWrappersServiceServer) CreateStringValue(context.Context, *wrapperspb.StringValue) (*wrapperspb.StringValue, error)

func (UnimplementedWrappersServiceServer) CreateUInt32Value 

func (UnimplementedWrappersServiceServer) CreateUInt32Value(context.Context, *wrapperspb.UInt32Value) (*wrapperspb.UInt32Value, error)

func (UnimplementedWrappersServiceServer) CreateUInt64Value 

func (UnimplementedWrappersServiceServer) CreateUInt64Value(context.Context, *wrapperspb.UInt64Value) (*wrapperspb.UInt64Value, error)

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 UnsafeSnakeEnumServiceServer 

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

UnsafeSnakeEnumServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to SnakeEnumServiceServer 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 UnsafeVisibilityRuleEchoServiceServer 

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

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

type UnsafeVisibilityRuleInternalEchoServiceServer 

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

UnsafeVisibilityRuleInternalEchoServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to VisibilityRuleInternalEchoServiceServer 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 VisibilityRuleEchoServiceClient 

type VisibilityRuleEchoServiceClient interface {
	// Echo method receives a simple message and returns it.
	// It should always be visible in the open API output.
	Echo(ctx context.Context, in *VisibilityRuleSimpleMessage, opts ...grpc.CallOption) (*VisibilityRuleSimpleMessage, error)
	// EchoInternal is an internal API that should only be visible in the OpenAPI spec
	// if `visibility_restriction_selectors` includes "INTERNAL".
	EchoInternal(ctx context.Context, in *VisibilityRuleSimpleMessage, opts ...grpc.CallOption) (*VisibilityRuleSimpleMessage, error)
	// EchoPreview is a preview API that should only be visible in the OpenAPI spec
	// if `visibility_restriction_selectors` includes "PREVIEW".
	EchoPreview(ctx context.Context, in *VisibilityRuleSimpleMessage, opts ...grpc.CallOption) (*VisibilityRuleMessageInPreviewMethod, error)
	// EchoInternalAndPreview is a internal and preview API that should only be visible in the OpenAPI spec
	// if `visibility_restriction_selectors` includes "PREVIEW" or "INTERNAL".
	EchoInternalAndPreview(ctx context.Context, in *VisibilityRuleSimpleMessage, opts ...grpc.CallOption) (*VisibilityRuleSimpleMessage, error)
}

VisibilityRuleEchoServiceClient is the client API for VisibilityRuleEchoService 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 NewVisibilityRuleEchoServiceClient 

func NewVisibilityRuleEchoServiceClient(cc grpc.ClientConnInterface) VisibilityRuleEchoServiceClient

type VisibilityRuleEchoServiceServer 

type VisibilityRuleEchoServiceServer interface {
	// Echo method receives a simple message and returns it.
	// It should always be visible in the open API output.
	Echo(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleSimpleMessage, error)
	// EchoInternal is an internal API that should only be visible in the OpenAPI spec
	// if `visibility_restriction_selectors` includes "INTERNAL".
	EchoInternal(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleSimpleMessage, error)
	// EchoPreview is a preview API that should only be visible in the OpenAPI spec
	// if `visibility_restriction_selectors` includes "PREVIEW".
	EchoPreview(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleMessageInPreviewMethod, error)
	// EchoInternalAndPreview is a internal and preview API that should only be visible in the OpenAPI spec
	// if `visibility_restriction_selectors` includes "PREVIEW" or "INTERNAL".
	EchoInternalAndPreview(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleSimpleMessage, error)
}

VisibilityRuleEchoServiceServer is the server API for VisibilityRuleEchoService service. All implementations should embed UnimplementedVisibilityRuleEchoServiceServer for forward compatibility

type VisibilityRuleEmbedded 

type VisibilityRuleEmbedded struct {

	// Types that are assignable to Mark:
	//	*VisibilityRuleEmbedded_Progress
	//	*VisibilityRuleEmbedded_Note
	//	*VisibilityRuleEmbedded_InternalField
	//	*VisibilityRuleEmbedded_PreviewField
	Mark isVisibilityRuleEmbedded_Mark `protobuf_oneof:"mark"`
	// contains filtered or unexported fields
}

Embedded represents a message embedded in SimpleMessage.

func (*VisibilityRuleEmbedded) Descriptor deprecated 

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

Deprecated: Use VisibilityRuleEmbedded.ProtoReflect.Descriptor instead.

func (*VisibilityRuleEmbedded) GetInternalField 

func (x *VisibilityRuleEmbedded) GetInternalField() string

func (*VisibilityRuleEmbedded) GetMark 

func (m *VisibilityRuleEmbedded) GetMark() isVisibilityRuleEmbedded_Mark

func (*VisibilityRuleEmbedded) GetNote 

func (x *VisibilityRuleEmbedded) GetNote() string

func (*VisibilityRuleEmbedded) GetPreviewField 

func (x *VisibilityRuleEmbedded) GetPreviewField() string

func (*VisibilityRuleEmbedded) GetProgress 

func (x *VisibilityRuleEmbedded) GetProgress() int64

func (*VisibilityRuleEmbedded) ProtoMessage 

func (*VisibilityRuleEmbedded) ProtoMessage()

func (*VisibilityRuleEmbedded) ProtoReflect 

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

func (*VisibilityRuleEmbedded) Reset 

func (x *VisibilityRuleEmbedded) Reset()

func (*VisibilityRuleEmbedded) String 

func (x *VisibilityRuleEmbedded) String() string

type VisibilityRuleEmbedded_InternalField 

type VisibilityRuleEmbedded_InternalField struct {
	InternalField string `protobuf:"bytes,3,opt,name=internal_field,json=internalField,proto3,oneof"`
}

type VisibilityRuleEmbedded_Note 

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

type VisibilityRuleEmbedded_PreviewField 

type VisibilityRuleEmbedded_PreviewField struct {
	PreviewField string `protobuf:"bytes,4,opt,name=preview_field,json=previewField,proto3,oneof"`
}

type VisibilityRuleEmbedded_Progress 

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

type VisibilityRuleEnumInPreviewMethod 

type VisibilityRuleEnumInPreviewMethod int32

EnumInPreviewMethod doesn't define its own visibility restrictions, but is only included in a method marked as "PREVIEW", so it will only appear if `visibility_restriction_selectors` include "PREVIEW". 

const (
	VisibilityRuleEnumInPreviewMethod_VISIBILITY_RULE_ENUM_IN_PREVIEW_METHOD_UNSPECIFIED VisibilityRuleEnumInPreviewMethod = 0
)

func (VisibilityRuleEnumInPreviewMethod) Descriptor 

func (VisibilityRuleEnumInPreviewMethod) Descriptor() protoreflect.EnumDescriptor

func (VisibilityRuleEnumInPreviewMethod) Enum 

func (x VisibilityRuleEnumInPreviewMethod) Enum() *VisibilityRuleEnumInPreviewMethod

func (VisibilityRuleEnumInPreviewMethod) EnumDescriptor deprecated 

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

Deprecated: Use VisibilityRuleEnumInPreviewMethod.Descriptor instead.

func (VisibilityRuleEnumInPreviewMethod) Number 

func (x VisibilityRuleEnumInPreviewMethod) Number() protoreflect.EnumNumber

func (VisibilityRuleEnumInPreviewMethod) String 

func (x VisibilityRuleEnumInPreviewMethod) String() string

func (VisibilityRuleEnumInPreviewMethod) Type 

func (VisibilityRuleEnumInPreviewMethod) Type() protoreflect.EnumType

type VisibilityRuleInternalEchoServiceClient 

type VisibilityRuleInternalEchoServiceClient interface {
	// Echo method receives a simple message and returns it.
	// It should not be visible in the open API output.
	Echo(ctx context.Context, in *VisibilityRuleSimpleMessage, opts ...grpc.CallOption) (*VisibilityRuleSimpleMessage, error)
}

VisibilityRuleInternalEchoServiceClient is the client API for VisibilityRuleInternalEchoService 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 NewVisibilityRuleInternalEchoServiceClient 

func NewVisibilityRuleInternalEchoServiceClient(cc grpc.ClientConnInterface) VisibilityRuleInternalEchoServiceClient

type VisibilityRuleInternalEchoServiceServer 

type VisibilityRuleInternalEchoServiceServer interface {
	// Echo method receives a simple message and returns it.
	// It should not be visible in the open API output.
	Echo(context.Context, *VisibilityRuleSimpleMessage) (*VisibilityRuleSimpleMessage, error)
}

VisibilityRuleInternalEchoServiceServer is the server API for VisibilityRuleInternalEchoService service. All implementations should embed UnimplementedVisibilityRuleInternalEchoServiceServer for forward compatibility

type VisibilityRuleMessageInPreviewMethod 

type VisibilityRuleMessageInPreviewMethod struct {
	Id         string                                   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SubMessage *VisibilityRuleSubMessageInPreviewMethod `protobuf:"bytes,2,opt,name=sub_message,json=subMessage,proto3" json:"sub_message,omitempty"`
	Enum       VisibilityRuleEnumInPreviewMethod        `` /* 148-byte string literal not displayed */
	// contains filtered or unexported fields
}

MessageInPreviewMethod doesn't define its own visibility restrictions, but is only included in a method marked as "PREVIEW", so it will only appear if `visibility_restriction_selectors` include "PREVIEW".

func (*VisibilityRuleMessageInPreviewMethod) Descriptor deprecated 

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

Deprecated: Use VisibilityRuleMessageInPreviewMethod.ProtoReflect.Descriptor instead.

func (*VisibilityRuleMessageInPreviewMethod) GetEnum 

func (x *VisibilityRuleMessageInPreviewMethod) GetEnum() VisibilityRuleEnumInPreviewMethod

func (*VisibilityRuleMessageInPreviewMethod) GetId 

func (x *VisibilityRuleMessageInPreviewMethod) GetId() string

func (*VisibilityRuleMessageInPreviewMethod) GetSubMessage 

func (x *VisibilityRuleMessageInPreviewMethod) GetSubMessage() *VisibilityRuleSubMessageInPreviewMethod

func (*VisibilityRuleMessageInPreviewMethod) ProtoMessage 

func (*VisibilityRuleMessageInPreviewMethod) ProtoMessage()

func (*VisibilityRuleMessageInPreviewMethod) ProtoReflect 

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

func (*VisibilityRuleMessageInPreviewMethod) Reset 

func (x *VisibilityRuleMessageInPreviewMethod) Reset()

func (*VisibilityRuleMessageInPreviewMethod) String 

func (x *VisibilityRuleMessageInPreviewMethod) String() string

type VisibilityRuleSimpleMessage 

type VisibilityRuleSimpleMessage 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:
	//	*VisibilityRuleSimpleMessage_LineNum
	//	*VisibilityRuleSimpleMessage_Lang
	Code   isVisibilityRuleSimpleMessage_Code `protobuf_oneof:"code"`
	Status *VisibilityRuleEmbedded            `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"`
	// Types that are assignable to Ext:
	//	*VisibilityRuleSimpleMessage_En
	//	*VisibilityRuleSimpleMessage_No
	Ext           isVisibilityRuleSimpleMessage_Ext          `protobuf_oneof:"ext"`
	InternalField string                                     `protobuf:"bytes,8,opt,name=internal_field,json=internalField,proto3" json:"internal_field,omitempty"`
	PreviewField  string                                     `protobuf:"bytes,9,opt,name=preview_field,json=previewField,proto3" json:"preview_field,omitempty"`
	AnEnum        VisibilityRuleSimpleMessage_VisibilityEnum `` /* 176-byte string literal not displayed */
	// contains filtered or unexported fields
}

SimpleMessage represents a simple message sent to the Echo service.

func (*VisibilityRuleSimpleMessage) Descriptor deprecated 

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

Deprecated: Use VisibilityRuleSimpleMessage.ProtoReflect.Descriptor instead.

func (*VisibilityRuleSimpleMessage) GetAnEnum 

func (x *VisibilityRuleSimpleMessage) GetAnEnum() VisibilityRuleSimpleMessage_VisibilityEnum

func (*VisibilityRuleSimpleMessage) GetCode 

func (m *VisibilityRuleSimpleMessage) GetCode() isVisibilityRuleSimpleMessage_Code

func (*VisibilityRuleSimpleMessage) GetEn 

func (x *VisibilityRuleSimpleMessage) GetEn() int64

func (*VisibilityRuleSimpleMessage) GetExt 

func (m *VisibilityRuleSimpleMessage) GetExt() isVisibilityRuleSimpleMessage_Ext

func (*VisibilityRuleSimpleMessage) GetId 

func (x *VisibilityRuleSimpleMessage) GetId() string

func (*VisibilityRuleSimpleMessage) GetInternalField 

func (x *VisibilityRuleSimpleMessage) GetInternalField() string

func (*VisibilityRuleSimpleMessage) GetLang 

func (x *VisibilityRuleSimpleMessage) GetLang() string

func (*VisibilityRuleSimpleMessage) GetLineNum 

func (x *VisibilityRuleSimpleMessage) GetLineNum() int64

func (*VisibilityRuleSimpleMessage) GetNo 

func (x *VisibilityRuleSimpleMessage) GetNo() *VisibilityRuleEmbedded

func (*VisibilityRuleSimpleMessage) GetNum 

func (x *VisibilityRuleSimpleMessage) GetNum() int64

func (*VisibilityRuleSimpleMessage) GetPreviewField 

func (x *VisibilityRuleSimpleMessage) GetPreviewField() string

func (*VisibilityRuleSimpleMessage) GetStatus 

func (x *VisibilityRuleSimpleMessage) GetStatus() *VisibilityRuleEmbedded

func (*VisibilityRuleSimpleMessage) ProtoMessage 

func (*VisibilityRuleSimpleMessage) ProtoMessage()

func (*VisibilityRuleSimpleMessage) ProtoReflect 

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

func (*VisibilityRuleSimpleMessage) Reset 

func (x *VisibilityRuleSimpleMessage) Reset()

func (*VisibilityRuleSimpleMessage) String 

func (x *VisibilityRuleSimpleMessage) String() string

type VisibilityRuleSimpleMessage_En 

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

type VisibilityRuleSimpleMessage_Lang 

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

type VisibilityRuleSimpleMessage_LineNum 

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

type VisibilityRuleSimpleMessage_No 

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

type VisibilityRuleSimpleMessage_VisibilityEnum 

type VisibilityRuleSimpleMessage_VisibilityEnum int32
const (
	VisibilityRuleSimpleMessage_VISIBILITY_ENUM_UNSPECIFIED VisibilityRuleSimpleMessage_VisibilityEnum = 0
	VisibilityRuleSimpleMessage_VISIBILITY_ENUM_VISIBLE     VisibilityRuleSimpleMessage_VisibilityEnum = 1
	VisibilityRuleSimpleMessage_VISIBILITY_ENUM_INTERNAL    VisibilityRuleSimpleMessage_VisibilityEnum = 2
	VisibilityRuleSimpleMessage_VISIBILITY_ENUM_PREVIEW     VisibilityRuleSimpleMessage_VisibilityEnum = 3
)

func (VisibilityRuleSimpleMessage_VisibilityEnum) Descriptor 

func (VisibilityRuleSimpleMessage_VisibilityEnum) Descriptor() protoreflect.EnumDescriptor

func (VisibilityRuleSimpleMessage_VisibilityEnum) Enum 

func (x VisibilityRuleSimpleMessage_VisibilityEnum) Enum() *VisibilityRuleSimpleMessage_VisibilityEnum

func (VisibilityRuleSimpleMessage_VisibilityEnum) EnumDescriptor deprecated 

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

Deprecated: Use VisibilityRuleSimpleMessage_VisibilityEnum.Descriptor instead.

func (VisibilityRuleSimpleMessage_VisibilityEnum) Number 

func (x VisibilityRuleSimpleMessage_VisibilityEnum) Number() protoreflect.EnumNumber

func (VisibilityRuleSimpleMessage_VisibilityEnum) String 

func (x VisibilityRuleSimpleMessage_VisibilityEnum) String() string

func (VisibilityRuleSimpleMessage_VisibilityEnum) Type 

func (VisibilityRuleSimpleMessage_VisibilityEnum) Type() protoreflect.EnumType

type VisibilityRuleSubMessageInPreviewMethod 

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

SubMessageInPreviewMethod doesn't define its own visibility restrictions, but is only included in a method marked as "PREVIEW", so it will only appear if `visibility_restriction_selectors` include "PREVIEW".

func (*VisibilityRuleSubMessageInPreviewMethod) Descriptor deprecated 

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

Deprecated: Use VisibilityRuleSubMessageInPreviewMethod.ProtoReflect.Descriptor instead.

func (*VisibilityRuleSubMessageInPreviewMethod) GetId 

func (x *VisibilityRuleSubMessageInPreviewMethod) GetId() string

func (*VisibilityRuleSubMessageInPreviewMethod) ProtoMessage 

func (*VisibilityRuleSubMessageInPreviewMethod) ProtoMessage()

func (*VisibilityRuleSubMessageInPreviewMethod) ProtoReflect 

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

func (*VisibilityRuleSubMessageInPreviewMethod) Reset 

func (x *VisibilityRuleSubMessageInPreviewMethod) Reset()

func (*VisibilityRuleSubMessageInPreviewMethod) String 

func (x *VisibilityRuleSubMessageInPreviewMethod) 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.

func NewWrappersServiceClient 

func NewWrappersServiceClient(cc grpc.ClientConnInterface) WrappersServiceClient

type WrappersServiceServer 

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

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.