package examplepb

const (
	ABitOfEverythingService_Create_FullMethodName                        = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Create"
	ABitOfEverythingService_CreateBody_FullMethodName                    = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBody"
	ABitOfEverythingService_CreateBook_FullMethodName                    = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CreateBook"
	ABitOfEverythingService_UpdateBook_FullMethodName                    = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateBook"
	ABitOfEverythingService_Lookup_FullMethodName                        = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Lookup"
	ABitOfEverythingService_Custom_FullMethodName                        = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Custom"
	ABitOfEverythingService_DoubleColon_FullMethodName                   = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DoubleColon"
	ABitOfEverythingService_Update_FullMethodName                        = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Update"
	ABitOfEverythingService_UpdateV2_FullMethodName                      = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/UpdateV2"
	ABitOfEverythingService_Delete_FullMethodName                        = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Delete"
	ABitOfEverythingService_GetQuery_FullMethodName                      = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetQuery"
	ABitOfEverythingService_GetRepeatedQuery_FullMethodName              = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetRepeatedQuery"
	ABitOfEverythingService_Echo_FullMethodName                          = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Echo"
	ABitOfEverythingService_DeepPathEcho_FullMethodName                  = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/DeepPathEcho"
	ABitOfEverythingService_NoBindings_FullMethodName                    = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/NoBindings"
	ABitOfEverythingService_Timeout_FullMethodName                       = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Timeout"
	ABitOfEverythingService_ErrorWithDetails_FullMethodName              = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/ErrorWithDetails"
	ABitOfEverythingService_GetMessageWithBody_FullMethodName            = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/GetMessageWithBody"
	ABitOfEverythingService_PostWithEmptyBody_FullMethodName             = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostWithEmptyBody"
	ABitOfEverythingService_CheckGetQueryParams_FullMethodName           = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckGetQueryParams"
	ABitOfEverythingService_CheckNestedEnumGetQueryParams_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckNestedEnumGetQueryParams"
	ABitOfEverythingService_CheckPostQueryParams_FullMethodName          = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckPostQueryParams"
	ABitOfEverythingService_OverwriteRequestContentType_FullMethodName   = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteRequestContentType"
	ABitOfEverythingService_OverwriteResponseContentType_FullMethodName  = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/OverwriteResponseContentType"
	ABitOfEverythingService_CheckExternalPathEnum_FullMethodName         = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalPathEnum"
	ABitOfEverythingService_CheckExternalNestedPathEnum_FullMethodName   = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckExternalNestedPathEnum"
	ABitOfEverythingService_CheckStatus_FullMethodName                   = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CheckStatus"
	ABitOfEverythingService_Exists_FullMethodName                        = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/Exists"
	ABitOfEverythingService_CustomOptionsRequest_FullMethodName          = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/CustomOptionsRequest"
	ABitOfEverythingService_TraceRequest_FullMethodName                  = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/TraceRequest"
	ABitOfEverythingService_PostOneofEnum_FullMethodName                 = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostOneofEnum"
	ABitOfEverythingService_PostRequiredMessageType_FullMethodName       = "/grpc.gateway.examples.internal.proto.examplepb.ABitOfEverythingService/PostRequiredMessageType"
)

const (
	EchoService_Echo_FullMethodName             = "/grpc.gateway.examples.internal.proto.examplepb.EchoService/Echo"
	EchoService_EchoBody_FullMethodName         = "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoBody"
	EchoService_EchoDelete_FullMethodName       = "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoDelete"
	EchoService_EchoPatch_FullMethodName        = "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoPatch"
	EchoService_EchoUnauthorized_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.EchoService/EchoUnauthorized"
)

const (
	FlowCombination_RpcEmptyRpc_FullMethodName               = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcEmptyRpc"
	FlowCombination_RpcEmptyStream_FullMethodName            = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcEmptyStream"
	FlowCombination_StreamEmptyRpc_FullMethodName            = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/StreamEmptyRpc"
	FlowCombination_StreamEmptyStream_FullMethodName         = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/StreamEmptyStream"
	FlowCombination_RpcBodyRpc_FullMethodName                = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyRpc"
	FlowCombination_RpcPathSingleNestedRpc_FullMethodName    = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathSingleNestedRpc"
	FlowCombination_RpcPathNestedRpc_FullMethodName          = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedRpc"
	FlowCombination_RpcBodyStream_FullMethodName             = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcBodyStream"
	FlowCombination_RpcPathSingleNestedStream_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathSingleNestedStream"
	FlowCombination_RpcPathNestedStream_FullMethodName       = "/grpc.gateway.examples.internal.proto.examplepb.FlowCombination/RpcPathNestedStream"
)

const (
	GenerateUnboundMethodsEchoService_Echo_FullMethodName       = "/grpc.gateway.examples.internal.proto.examplepb.GenerateUnboundMethodsEchoService/Echo"
	GenerateUnboundMethodsEchoService_EchoBody_FullMethodName   = "/grpc.gateway.examples.internal.proto.examplepb.GenerateUnboundMethodsEchoService/EchoBody"
	GenerateUnboundMethodsEchoService_EchoDelete_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.GenerateUnboundMethodsEchoService/EchoDelete"
)

const (
	NonStandardService_Update_FullMethodName              = "/grpc.gateway.examples.internal.proto.examplepb.NonStandardService/Update"
	NonStandardService_UpdateWithJSONNames_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.NonStandardService/UpdateWithJSONNames"
)

const (
	ServiceA_MethodOne_FullMethodName = "/grpc.gateway.examples.internal.examplepb.ServiceA/MethodOne"
	ServiceA_MethodTwo_FullMethodName = "/grpc.gateway.examples.internal.examplepb.ServiceA/MethodTwo"
)

const (
	ServiceC_MethodOne_FullMethodName = "/grpc.gateway.examples.internal.examplepb.ServiceC/MethodOne"
	ServiceC_MethodTwo_FullMethodName = "/grpc.gateway.examples.internal.examplepb.ServiceC/MethodTwo"
)

const (
	ServiceB_MethodOne_FullMethodName = "/grpc.gateway.examples.internal.examplepb.ServiceB/MethodOne"
	ServiceB_MethodTwo_FullMethodName = "/grpc.gateway.examples.internal.examplepb.ServiceB/MethodTwo"
)

const (
	ResponseBodyService_GetResponseBody_FullMethodName       = "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/GetResponseBody"
	ResponseBodyService_ListResponseBodies_FullMethodName    = "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/ListResponseBodies"
	ResponseBodyService_ListResponseStrings_FullMethodName   = "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/ListResponseStrings"
	ResponseBodyService_GetResponseBodyStream_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.ResponseBodyService/GetResponseBodyStream"
)

const (
	StreamService_BulkCreate_FullMethodName       = "/grpc.gateway.examples.internal.proto.examplepb.StreamService/BulkCreate"
	StreamService_List_FullMethodName             = "/grpc.gateway.examples.internal.proto.examplepb.StreamService/List"
	StreamService_BulkEcho_FullMethodName         = "/grpc.gateway.examples.internal.proto.examplepb.StreamService/BulkEcho"
	StreamService_BulkEchoDuration_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.StreamService/BulkEchoDuration"
	StreamService_Download_FullMethodName         = "/grpc.gateway.examples.internal.proto.examplepb.StreamService/Download"
)

const (
	UnannotatedEchoService_Echo_FullMethodName       = "/grpc.gateway.examples.internal.proto.examplepb.UnannotatedEchoService/Echo"
	UnannotatedEchoService_EchoBody_FullMethodName   = "/grpc.gateway.examples.internal.proto.examplepb.UnannotatedEchoService/EchoBody"
	UnannotatedEchoService_EchoDelete_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.UnannotatedEchoService/EchoDelete"
)

const (
	LoginService_Login_FullMethodName  = "/grpc.gateway.examples.internal.proto.examplepb.LoginService/Login"
	LoginService_Logout_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.LoginService/Logout"
)

const (
	VisibilityRuleEchoService_Echo_FullMethodName                   = "/grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleEchoService/Echo"
	VisibilityRuleEchoService_EchoInternal_FullMethodName           = "/grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleEchoService/EchoInternal"
	VisibilityRuleEchoService_EchoPreview_FullMethodName            = "/grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleEchoService/EchoPreview"
	VisibilityRuleEchoService_EchoInternalAndPreview_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleEchoService/EchoInternalAndPreview"
)

const (
	WrappersService_Create_FullMethodName            = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/Create"
	WrappersService_CreateStringValue_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateStringValue"
	WrappersService_CreateInt32Value_FullMethodName  = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateInt32Value"
	WrappersService_CreateInt64Value_FullMethodName  = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateInt64Value"
	WrappersService_CreateFloatValue_FullMethodName  = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateFloatValue"
	WrappersService_CreateDoubleValue_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateDoubleValue"
	WrappersService_CreateBoolValue_FullMethodName   = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateBoolValue"
	WrappersService_CreateUInt32Value_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateUInt32Value"
	WrappersService_CreateUInt64Value_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateUInt64Value"
	WrappersService_CreateBytesValue_FullMethodName  = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateBytesValue"
	WrappersService_CreateEmpty_FullMethodName       = "/grpc.gateway.examples.internal.proto.examplepb.WrappersService/CreateEmpty"
)

const (
	AnotherServiceWithNoBindings_NoBindings_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.AnotherServiceWithNoBindings/NoBindings"
)

const (
	CamelCaseServiceName_Empty_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.camelCaseServiceName/Empty"
)

const (
	EnumWithSingleValueService_Echo_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.EnumWithSingleValueService/Echo"
)

const (
	Foo2Service_Foo2_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.Foo2Service/Foo2"
)

const (
	FooService_Foo_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.FooService/Foo"
)

const (
	SnakeEnumService_SnakeEnum_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.SnakeEnumService/SnakeEnum"
)

const (
	VisibilityRuleInternalEchoService_Echo_FullMethodName = "/grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleInternalEchoService/Echo"
)

Variables ¶

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

Enum value maps for NumericEnum.

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.

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.

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.

var (
	EnumWithSingleValue_name = map[int32]string{
		0: "ENUM_WITH_SINGLE_VALUE_UNSPECIFIED",
	}
	EnumWithSingleValue_value = map[string]int32{
		"ENUM_WITH_SINGLE_VALUE_UNSPECIFIED": 0,
	}
)

Enum value maps for EnumWithSingleValue.

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.

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.

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.

var (
	VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault_name = map[int32]string{
		0: "VISIBILITY_ENUM_HIDDEN_DEFAULT_UNSPECIFIED",
		1: "VISIBILITY_ENUM_HIDDEN_DEFAULT_VISIBLE",
	}
	VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault_value = map[string]int32{
		"VISIBILITY_ENUM_HIDDEN_DEFAULT_UNSPECIFIED": 0,
		"VISIBILITY_ENUM_HIDDEN_DEFAULT_VISIBLE":     1,
	}
)

Enum value maps for VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault.

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: "OverwriteRequestContentType",
			Handler:    _ABitOfEverythingService_OverwriteRequestContentType_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)

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)

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)

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)

var EnumWithSingleValueService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.EnumWithSingleValueService",
	HandlerType: (*EnumWithSingleValueServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Echo",
			Handler:    _EnumWithSingleValueService_Echo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/enum_with_single_value.proto",
}

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

var File_examples_internal_proto_examplepb_a_bit_of_everything_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_echo_service_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_enum_with_single_value_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_flow_combination_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_generate_unbound_methods_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_ignore_comment_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_non_standard_names_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_openapi_merge_a_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_openapi_merge_b_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_remove_internal_comment_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_response_body_service_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_stream_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_unannotated_echo_service_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_use_go_template_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_visibility_rule_echo_service_proto protoreflect.FileDescriptor

var File_examples_internal_proto_examplepb_wrappers_proto protoreflect.FileDescriptor

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)

var Foo2Service_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.Foo2Service",
	HandlerType: (*Foo2ServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Foo2",
			Handler:    _Foo2Service_Foo2_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/remove_internal_comment.proto",
}

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

var FooService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "grpc.gateway.examples.internal.proto.examplepb.FooService",
	HandlerType: (*FooServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Foo",
			Handler:    _FooService_Foo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "examples/internal/proto/examplepb/ignore_comment.proto",
}

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

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)

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)

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)

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)

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)

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)

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)

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)

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:    "BulkEchoDuration",
			Handler:       _StreamService_BulkEchoDuration_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)

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)

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)

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)

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

func RegisterEchoServiceServer ¶

func RegisterEchoServiceServer(s grpc.ServiceRegistrar, srv EchoServiceServer)

func RegisterEnumWithSingleValueServiceHandler ¶

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

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

func RegisterEnumWithSingleValueServiceHandlerClient ¶

func RegisterEnumWithSingleValueServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client EnumWithSingleValueServiceClient) error

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

func RegisterEnumWithSingleValueServiceHandlerFromEndpoint ¶

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

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

func RegisterEnumWithSingleValueServiceHandlerServer ¶

func RegisterEnumWithSingleValueServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server EnumWithSingleValueServiceServer) error

RegisterEnumWithSingleValueServiceHandlerServer registers the http handlers for service EnumWithSingleValueService to "mux". UnaryRPC :call EnumWithSingleValueServiceServer 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 RegisterEnumWithSingleValueServiceHandlerFromEndpoint instead. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

func RegisterEnumWithSingleValueServiceServer ¶

func RegisterEnumWithSingleValueServiceServer(s grpc.ServiceRegistrar, srv EnumWithSingleValueServiceServer)

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

func RegisterFlowCombinationServer ¶

func RegisterFlowCombinationServer(s grpc.ServiceRegistrar, srv FlowCombinationServer)

func RegisterFoo2ServiceHandler ¶

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

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

func RegisterFoo2ServiceHandlerClient ¶

func RegisterFoo2ServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client Foo2ServiceClient) error

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

func RegisterFoo2ServiceHandlerFromEndpoint ¶

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

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

func RegisterFoo2ServiceHandlerServer ¶

func RegisterFoo2ServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server Foo2ServiceServer) error

RegisterFoo2ServiceHandlerServer registers the http handlers for service Foo2Service to "mux". UnaryRPC :call Foo2ServiceServer 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 RegisterFoo2ServiceHandlerFromEndpoint instead. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

func RegisterFoo2ServiceServer ¶

func RegisterFoo2ServiceServer(s grpc.ServiceRegistrar, srv Foo2ServiceServer)

func RegisterFooServiceHandler ¶

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

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

func RegisterFooServiceHandlerClient ¶

func RegisterFooServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FooServiceClient) error

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

func RegisterFooServiceHandlerFromEndpoint ¶

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

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

func RegisterFooServiceHandlerServer ¶

func RegisterFooServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server FooServiceServer) error

RegisterFooServiceHandlerServer registers the http handlers for service FooService to "mux". UnaryRPC :call FooServiceServer 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 RegisterFooServiceHandlerFromEndpoint instead. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

func RegisterFooServiceServer ¶

func RegisterFooServiceServer(s grpc.ServiceRegistrar, srv FooServiceServer)

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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. This client ignores the HTTP middlewares.

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. GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.

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                             `protobuf:"varint,14,opt,name=enum_value,json=enumValue,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.NumericEnum" json:"enum_value,omitempty"`
	PathEnumValue       pathenum.PathEnum                       `protobuf:"varint,30,opt,name=path_enum_value,json=pathEnumValue,proto3,enum=grpc.gateway.examples.internal.pathenum.PathEnum" json:"path_enum_value,omitempty"`
	NestedPathEnumValue pathenum.MessagePathEnum_NestedPathEnum `protobuf:"varint,31,opt,name=nested_path_enum_value,json=nestedPathEnumValue,proto3,enum=grpc.gateway.examples.internal.pathenum.MessagePathEnum_NestedPathEnum" json:"nested_path_enum_value,omitempty"`
	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"`
	// map of numeric enum
	MapValue map[string]NumericEnum `protobuf:"bytes,22,rep,name=map_value,json=mapValue,proto3" json:"map_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.NumericEnum"`
	// map of string  (This comment is overridden by the field annotation)
	MappedStringValue        map[string]string                   `protobuf:"bytes,23,rep,name=mapped_string_value,json=mappedStringValue,proto3" json:"mapped_string_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	MappedNestedValue        map[string]*ABitOfEverything_Nested `protobuf:"bytes,24,rep,name=mapped_nested_value,json=mappedNestedValue,proto3" json:"mapped_nested_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	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 `protobuf:"varint,28,rep,packed,name=repeated_enum_value,json=repeatedEnumValue,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.NumericEnum" json:"repeated_enum_value,omitempty"`
	// repeated numeric enum comment (This comment is overridden by the field annotation)
	RepeatedEnumAnnotation []NumericEnum `protobuf:"varint,32,rep,packed,name=repeated_enum_annotation,json=repeatedEnumAnnotation,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.NumericEnum" json:"repeated_enum_annotation,omitempty"`
	// numeric enum comment (This comment is overridden by the field annotation)
	EnumValueAnnotation NumericEnum `protobuf:"varint,33,opt,name=enum_value_annotation,json=enumValueAnnotation,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.NumericEnum" json:"enum_value_annotation,omitempty"`
	// repeated string comment (This comment is overridden by the field annotation)
	RepeatedStringAnnotation []string `protobuf:"bytes,34,rep,name=repeated_string_annotation,json=repeatedStringAnnotation,proto3" json:"repeated_string_annotation,omitempty"`
	// repeated nested object comment (This comment is overridden by the field annotation)
	RepeatedNestedAnnotation []*ABitOfEverything_Nested `protobuf:"bytes,35,rep,name=repeated_nested_annotation,json=repeatedNestedAnnotation,proto3" json:"repeated_nested_annotation,omitempty"`
	// 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 `protobuf:"bytes,38,opt,name=required_string_via_field_behavior_annotation,json=requiredStringViaFieldBehaviorAnnotation,proto3" json:"required_string_via_field_behavior_annotation,omitempty"`
	// mark a field as readonly in Open API definition
	OutputOnlyStringViaFieldBehaviorAnnotation string  `protobuf:"bytes,39,opt,name=output_only_string_via_field_behavior_annotation,json=outputOnlyStringViaFieldBehaviorAnnotation,proto3" json:"output_only_string_via_field_behavior_annotation,omitempty"`
	OptionalStringValue                        *string `protobuf:"bytes,40,opt,name=optional_string_value,json=optionalStringValue,proto3,oneof" json:"optional_string_value,omitempty"`
	// 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 `protobuf:"bytes,43,opt,name=required_string_field_1,json=requiredStringField1,proto3" json:"required_string_field_1,omitempty"`
	RequiredStringField_2 string `protobuf:"bytes,44,opt,name=required_string_field_2,json=requiredStringField2,proto3" json:"required_string_field_2,omitempty"`
	// Test openapiv2 handling of required json_name fields
	RequiredFieldBehaviorJsonName string `protobuf:"bytes,45,opt,name=required_field_behavior_json_name,json=required_field_behavior_json_name_custom,proto3" json:"required_field_behavior_json_name,omitempty"`
	RequiredFieldSchemaJsonName   string `protobuf:"bytes,46,opt,name=required_field_schema_json_name,json=required_field_schema_json_name_custom,proto3" json:"required_field_schema_json_name,omitempty"`
	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.
	// Specify a custom format of repeated field items
	Uuids []string `protobuf:"bytes,51,rep,name=uuids,proto3" json:"uuids,omitempty"`
	// contains filtered or unexported fields
}

Intentionally complicated message type to cover many features of Protobuf.

func (*ABitOfEverything) Descriptor ¶

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) GetUuids ¶

func (x *ABitOfEverything) GetUuids() []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     `protobuf:"fixed32,1,rep,packed,name=path_repeated_float_value,json=pathRepeatedFloatValue,proto3" json:"path_repeated_float_value,omitempty"`
	PathRepeatedDoubleValue   []float64     `protobuf:"fixed64,2,rep,packed,name=path_repeated_double_value,json=pathRepeatedDoubleValue,proto3" json:"path_repeated_double_value,omitempty"`
	PathRepeatedInt64Value    []int64       `protobuf:"varint,3,rep,packed,name=path_repeated_int64_value,json=pathRepeatedInt64Value,proto3" json:"path_repeated_int64_value,omitempty"`
	PathRepeatedUint64Value   []uint64      `protobuf:"varint,4,rep,packed,name=path_repeated_uint64_value,json=pathRepeatedUint64Value,proto3" json:"path_repeated_uint64_value,omitempty"`
	PathRepeatedInt32Value    []int32       `protobuf:"varint,5,rep,packed,name=path_repeated_int32_value,json=pathRepeatedInt32Value,proto3" json:"path_repeated_int32_value,omitempty"`
	PathRepeatedFixed64Value  []uint64      `protobuf:"fixed64,6,rep,packed,name=path_repeated_fixed64_value,json=pathRepeatedFixed64Value,proto3" json:"path_repeated_fixed64_value,omitempty"`
	PathRepeatedFixed32Value  []uint32      `protobuf:"fixed32,7,rep,packed,name=path_repeated_fixed32_value,json=pathRepeatedFixed32Value,proto3" json:"path_repeated_fixed32_value,omitempty"`
	PathRepeatedBoolValue     []bool        `protobuf:"varint,8,rep,packed,name=path_repeated_bool_value,json=pathRepeatedBoolValue,proto3" json:"path_repeated_bool_value,omitempty"`
	PathRepeatedStringValue   []string      `protobuf:"bytes,9,rep,name=path_repeated_string_value,json=pathRepeatedStringValue,proto3" json:"path_repeated_string_value,omitempty"`
	PathRepeatedBytesValue    [][]byte      `protobuf:"bytes,10,rep,name=path_repeated_bytes_value,json=pathRepeatedBytesValue,proto3" json:"path_repeated_bytes_value,omitempty"`
	PathRepeatedUint32Value   []uint32      `protobuf:"varint,11,rep,packed,name=path_repeated_uint32_value,json=pathRepeatedUint32Value,proto3" json:"path_repeated_uint32_value,omitempty"`
	PathRepeatedEnumValue     []NumericEnum `protobuf:"varint,12,rep,packed,name=path_repeated_enum_value,json=pathRepeatedEnumValue,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.NumericEnum" json:"path_repeated_enum_value,omitempty"`
	PathRepeatedSfixed32Value []int32       `protobuf:"fixed32,13,rep,packed,name=path_repeated_sfixed32_value,json=pathRepeatedSfixed32Value,proto3" json:"path_repeated_sfixed32_value,omitempty"`
	PathRepeatedSfixed64Value []int64       `protobuf:"fixed64,14,rep,packed,name=path_repeated_sfixed64_value,json=pathRepeatedSfixed64Value,proto3" json:"path_repeated_sfixed64_value,omitempty"`
	PathRepeatedSint32Value   []int32       `protobuf:"zigzag32,15,rep,packed,name=path_repeated_sint32_value,json=pathRepeatedSint32Value,proto3" json:"path_repeated_sint32_value,omitempty"`
	PathRepeatedSint64Value   []int64       `protobuf:"zigzag64,16,rep,packed,name=path_repeated_sint64_value,json=pathRepeatedSint64Value,proto3" json:"path_repeated_sint64_value,omitempty"`
	// contains filtered or unexported fields
}

ABitOfEverythingRepeated is used to validate repeated path parameter functionality

func (*ABitOfEverythingRepeated) Descriptor ¶

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)
	OverwriteRequestContentType(ctx context.Context, in *Body, opts ...grpc.CallOption) (*emptypb.Empty, 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.

ABitOfEverything service is used to validate that APIs with complicated proto messages and URL templates are still processed correctly.

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)
	OverwriteRequestContentType(context.Context, *Body) (*emptypb.Empty, 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.

ABitOfEverything service is used to validate that APIs with complicated proto messages and URL templates are still processed correctly.

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 `protobuf:"varint,3,opt,name=ok,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.ABitOfEverything_Nested_DeepEnum" json:"ok,omitempty"`
	// contains filtered or unexported fields
}

Nested is nested type.

func (*ABitOfEverything_Nested) Descriptor ¶

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 ¶

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 ¶

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 ¶

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 ¶

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.

camelCase and lowercase service names are valid but not recommended (use TitleCase instead)

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.

camelCase and lowercase service names are valid but not recommended (use TitleCase instead)

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 ¶

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 ¶

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 ¶

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 ¶

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.

Echo service responds to incoming echo requests.

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.

Echo service responds to incoming echo requests.

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 ¶

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 ¶

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 EnumWithSingleValue ¶

type EnumWithSingleValue int32

EnumWithSingleValue is an enum with a single value. Since it has just a single value the `enum` field should be omitted in the generated OpenAPI spec for the type when the omit_enum_default_value option is set to true.

const (
	EnumWithSingleValue_ENUM_WITH_SINGLE_VALUE_UNSPECIFIED EnumWithSingleValue = 0
)

func (EnumWithSingleValue) Descriptor ¶

func (EnumWithSingleValue) Descriptor() protoreflect.EnumDescriptor

func (EnumWithSingleValue) Enum ¶

func (x EnumWithSingleValue) Enum() *EnumWithSingleValue

func (EnumWithSingleValue) EnumDescriptor ¶

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

Deprecated: Use EnumWithSingleValue.Descriptor instead.

func (EnumWithSingleValue) Number ¶

func (x EnumWithSingleValue) Number() protoreflect.EnumNumber

func (EnumWithSingleValue) String ¶

func (x EnumWithSingleValue) String() string

func (EnumWithSingleValue) Type ¶

func (EnumWithSingleValue) Type() protoreflect.EnumType

type EnumWithSingleValueServiceClient ¶

type EnumWithSingleValueServiceClient interface {
	Echo(ctx context.Context, in *EnumWithSingleValueServiceEchoRequest, opts ...grpc.CallOption) (*EnumWithSingleValueServiceEchoResponse, error)
}

EnumWithSingleValueServiceClient is the client API for EnumWithSingleValueService 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 NewEnumWithSingleValueServiceClient ¶

func NewEnumWithSingleValueServiceClient(cc grpc.ClientConnInterface) EnumWithSingleValueServiceClient

type EnumWithSingleValueServiceEchoRequest ¶

type EnumWithSingleValueServiceEchoRequest struct {
	Value EnumWithSingleValue `protobuf:"varint,1,opt,name=value,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.EnumWithSingleValue" json:"value,omitempty"`
	// contains filtered or unexported fields
}

func (*EnumWithSingleValueServiceEchoRequest) Descriptor ¶

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

Deprecated: Use EnumWithSingleValueServiceEchoRequest.ProtoReflect.Descriptor instead.

func (*EnumWithSingleValueServiceEchoRequest) GetValue ¶

func (x *EnumWithSingleValueServiceEchoRequest) GetValue() EnumWithSingleValue

func (*EnumWithSingleValueServiceEchoRequest) ProtoMessage ¶

func (*EnumWithSingleValueServiceEchoRequest) ProtoMessage()

func (*EnumWithSingleValueServiceEchoRequest) ProtoReflect ¶

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

func (*EnumWithSingleValueServiceEchoRequest) Reset ¶

func (x *EnumWithSingleValueServiceEchoRequest) Reset()

func (*EnumWithSingleValueServiceEchoRequest) String ¶

func (x *EnumWithSingleValueServiceEchoRequest) String() string

type EnumWithSingleValueServiceEchoResponse ¶

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

func (*EnumWithSingleValueServiceEchoResponse) Descriptor ¶

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

Deprecated: Use EnumWithSingleValueServiceEchoResponse.ProtoReflect.Descriptor instead.

func (*EnumWithSingleValueServiceEchoResponse) ProtoMessage ¶

func (*EnumWithSingleValueServiceEchoResponse) ProtoMessage()

func (*EnumWithSingleValueServiceEchoResponse) ProtoReflect ¶

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

func (*EnumWithSingleValueServiceEchoResponse) Reset ¶

func (x *EnumWithSingleValueServiceEchoResponse) Reset()

func (*EnumWithSingleValueServiceEchoResponse) String ¶

func (x *EnumWithSingleValueServiceEchoResponse) String() string

type EnumWithSingleValueServiceServer ¶

type EnumWithSingleValueServiceServer interface {
	Echo(context.Context, *EnumWithSingleValueServiceEchoRequest) (*EnumWithSingleValueServiceEchoResponse, error)
}

EnumWithSingleValueServiceServer is the server API for EnumWithSingleValueService service. All implementations should embed UnimplementedEnumWithSingleValueServiceServer for forward compatibility.

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 ¶

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 ¶

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) (grpc.ServerStreamingClient[EmptyProto], error)
	StreamEmptyRpc(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[EmptyProto, EmptyProto], error)
	StreamEmptyStream(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[EmptyProto, EmptyProto], 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) (grpc.ServerStreamingClient[EmptyProto], error)
	RpcPathSingleNestedStream(ctx context.Context, in *SingleNestedProto, opts ...grpc.CallOption) (grpc.ServerStreamingClient[EmptyProto], error)
	RpcPathNestedStream(ctx context.Context, in *NestedProto, opts ...grpc.CallOption) (grpc.ServerStreamingClient[EmptyProto], 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, grpc.ServerStreamingServer[EmptyProto]) error
	StreamEmptyRpc(grpc.ClientStreamingServer[EmptyProto, EmptyProto]) error
	StreamEmptyStream(grpc.BidiStreamingServer[EmptyProto, EmptyProto]) error
	RpcBodyRpc(context.Context, *NonEmptyProto) (*EmptyProto, error)
	RpcPathSingleNestedRpc(context.Context, *SingleNestedProto) (*EmptyProto, error)
	RpcPathNestedRpc(context.Context, *NestedProto) (*EmptyProto, error)
	RpcBodyStream(*NonEmptyProto, grpc.ServerStreamingServer[EmptyProto]) error
	RpcPathSingleNestedStream(*SingleNestedProto, grpc.ServerStreamingServer[EmptyProto]) error
	RpcPathNestedStream(*NestedProto, grpc.ServerStreamingServer[EmptyProto]) error
}

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

type FlowCombination_RpcBodyStreamClient ¶

type FlowCombination_RpcBodyStreamClient = grpc.ServerStreamingClient[EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_RpcBodyStreamServer ¶

type FlowCombination_RpcBodyStreamServer = grpc.ServerStreamingServer[EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_RpcEmptyStreamClient ¶

type FlowCombination_RpcEmptyStreamClient = grpc.ServerStreamingClient[EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_RpcEmptyStreamServer ¶

type FlowCombination_RpcEmptyStreamServer = grpc.ServerStreamingServer[EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_RpcPathNestedStreamClient ¶

type FlowCombination_RpcPathNestedStreamClient = grpc.ServerStreamingClient[EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_RpcPathNestedStreamServer ¶

type FlowCombination_RpcPathNestedStreamServer = grpc.ServerStreamingServer[EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_RpcPathSingleNestedStreamClient ¶

type FlowCombination_RpcPathSingleNestedStreamClient = grpc.ServerStreamingClient[EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_RpcPathSingleNestedStreamServer ¶

type FlowCombination_RpcPathSingleNestedStreamServer = grpc.ServerStreamingServer[EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_StreamEmptyRpcClient ¶

type FlowCombination_StreamEmptyRpcClient = grpc.ClientStreamingClient[EmptyProto, EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_StreamEmptyRpcServer ¶

type FlowCombination_StreamEmptyRpcServer = grpc.ClientStreamingServer[EmptyProto, EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_StreamEmptyStreamClient ¶

type FlowCombination_StreamEmptyStreamClient = grpc.BidiStreamingClient[EmptyProto, EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type FlowCombination_StreamEmptyStreamServer ¶

type FlowCombination_StreamEmptyStreamServer = grpc.BidiStreamingServer[EmptyProto, EmptyProto]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

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 ¶

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 Foo2Reply ¶

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

(-- This comment should be excluded from OpenAPI output --)

func (*Foo2Reply) Descriptor ¶

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

Deprecated: Use Foo2Reply.ProtoReflect.Descriptor instead.

func (*Foo2Reply) ProtoMessage ¶

func (*Foo2Reply) ProtoMessage()

func (*Foo2Reply) ProtoReflect ¶

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

func (*Foo2Reply) Reset ¶

func (x *Foo2Reply) Reset()

func (*Foo2Reply) String ¶

func (x *Foo2Reply) String() string

type Foo2Request ¶

type Foo2Request struct {

	// Username.
	// (-- This comment should be excluded
	// from OpenAPI output --)
	// Same row, single line break doesn't count on markdown.
	Username string `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	// Password.
	// (-- This comment should be excluded
	// from OpenAPI output --)
	//
	// New row.
	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	// contains filtered or unexported fields
}

Foo2Request (-- This comment should be excluded from OpenAPI output --)

func (*Foo2Request) Descriptor ¶

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

Deprecated: Use Foo2Request.ProtoReflect.Descriptor instead.

func (*Foo2Request) GetPassword ¶

func (x *Foo2Request) GetPassword() string

func (*Foo2Request) GetUsername ¶

func (x *Foo2Request) GetUsername() string

func (*Foo2Request) ProtoMessage ¶

func (*Foo2Request) ProtoMessage()

func (*Foo2Request) ProtoReflect ¶

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

func (*Foo2Request) Reset ¶

func (x *Foo2Request) Reset()

func (*Foo2Request) String ¶

func (x *Foo2Request) String() string

type Foo2ServiceClient ¶

type Foo2ServiceClient interface {
	// Foo Summary (-- This comment should be excluded from OpenAPI output --)
	//
	// (-- This comment should be excluded from OpenAPI output --)
	// Description
	Foo2(ctx context.Context, in *Foo2Request, opts ...grpc.CallOption) (*Foo2Reply, error)
}

Foo2ServiceClient is the client API for Foo2Service 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.

Foo2Service (-- This comment should be excluded from OpenAPI output --)

func NewFoo2ServiceClient ¶

func NewFoo2ServiceClient(cc grpc.ClientConnInterface) Foo2ServiceClient

type Foo2ServiceServer ¶

type Foo2ServiceServer interface {
	// Foo Summary (-- This comment should be excluded from OpenAPI output --)
	//
	// (-- This comment should be excluded from OpenAPI output --)
	// Description
	Foo2(context.Context, *Foo2Request) (*Foo2Reply, error)
}

Foo2ServiceServer is the server API for Foo2Service service. All implementations should embed UnimplementedFoo2ServiceServer for forward compatibility.

Foo2Service (-- This comment should be excluded from OpenAPI output --)

type FooReply ¶

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

This comment should be excluded from OpenAPI output

func (*FooReply) Descriptor ¶

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

Deprecated: Use FooReply.ProtoReflect.Descriptor instead.

func (*FooReply) ProtoMessage ¶

func (*FooReply) ProtoMessage()

func (*FooReply) ProtoReflect ¶

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

func (*FooReply) Reset ¶

func (x *FooReply) Reset()

func (*FooReply) String ¶

func (x *FooReply) String() string

type FooRequest ¶

type FooRequest struct {

	// This comment should be excluded from OpenAPI output
	Username string `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	// This comment should be excluded from OpenAPI output
	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	// contains filtered or unexported fields
}

This comment should be excluded from OpenAPI output

func (*FooRequest) Descriptor ¶

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

Deprecated: Use FooRequest.ProtoReflect.Descriptor instead.

func (*FooRequest) GetPassword ¶

func (x *FooRequest) GetPassword() string

func (*FooRequest) GetUsername ¶

func (x *FooRequest) GetUsername() string

func (*FooRequest) ProtoMessage ¶

func (*FooRequest) ProtoMessage()

func (*FooRequest) ProtoReflect ¶

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

func (*FooRequest) Reset ¶

func (x *FooRequest) Reset()

func (*FooRequest) String ¶

func (x *FooRequest) String() string

type FooServiceClient ¶

type FooServiceClient interface {
	// This comment should be excluded from OpenAPI output
	Foo(ctx context.Context, in *FooRequest, opts ...grpc.CallOption) (*FooReply, error)
}

FooServiceClient is the client API for FooService 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.

This comment should be excluded from OpenAPI output

func NewFooServiceClient ¶

func NewFooServiceClient(cc grpc.ClientConnInterface) FooServiceClient

type FooServiceServer ¶

type FooServiceServer interface {
	// This comment should be excluded from OpenAPI output
	Foo(context.Context, *FooRequest) (*FooReply, error)
}

FooServiceServer is the server API for FooService service. All implementations should embed UnimplementedFooServiceServer for forward compatibility.

This comment should be excluded from OpenAPI output

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.

GenerateUnboundMethodsEchoService service responds to incoming echo requests.

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.

GenerateUnboundMethodsEchoService service responds to incoming echo requests.

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 successful or not
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

func (*LogoutReply) Descriptor ¶

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 [] in front of the type
	Stringarray []string `protobuf:"bytes,3,rep,name=stringarray,proto3" json:"stringarray,omitempty"`
	// contains filtered or unexported fields
}

func (*LogoutRequest) Descriptor ¶

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 ¶

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 NestedMessage ¶

type NestedMessage struct {
	NId string `protobuf:"bytes,1,opt,name=n_id,json=nId,proto3" json:"n_id,omitempty"`
	Val string `protobuf:"bytes,2,opt,name=val,proto3" json:"val,omitempty"`
	// contains filtered or unexported fields
}

func (*NestedMessage) Descriptor ¶

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

Deprecated: Use NestedMessage.ProtoReflect.Descriptor instead.

func (*NestedMessage) GetNId ¶

func (x *NestedMessage) GetNId() string

func (*NestedMessage) GetVal ¶

func (x *NestedMessage) GetVal() string

func (*NestedMessage) ProtoMessage ¶

func (*NestedMessage) ProtoMessage()

func (*NestedMessage) ProtoReflect ¶

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

func (*NestedMessage) Reset ¶

func (x *NestedMessage) Reset()

func (*NestedMessage) String ¶

func (x *NestedMessage) 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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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.

NonStandardService responds to incoming messages, applies a field mask and returns the masked response.

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.

NonStandardService responds to incoming messages, applies a field mask and returns the masked response.

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 ¶

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 ¶

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 ¶

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 Options ¶

type Options struct {
	Error bool `protobuf:"varint,1,opt,name=error,proto3" json:"error,omitempty"`
	// contains filtered or unexported fields
}

func (*Options) Descriptor ¶

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

Deprecated: Use Options.ProtoReflect.Descriptor instead.

func (*Options) GetError ¶

func (x *Options) GetError() bool

func (*Options) ProtoMessage ¶

func (*Options) ProtoMessage()

func (*Options) ProtoReflect ¶

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

func (*Options) Reset ¶

func (x *Options) Reset()

func (*Options) String ¶

func (x *Options) String() string

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 ¶

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 ¶

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 ¶

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 ¶

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 `protobuf:"varint,3,opt,name=type,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.RepeatedResponseBodyOut_Response_ResponseType" json:"type,omitempty"`
	// contains filtered or unexported fields
}

func (*RepeatedResponseBodyOut_Response) Descriptor ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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 ¶

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) (grpc.ServerStreamingClient[ResponseBodyOut], 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, grpc.ServerStreamingServer[ResponseBodyOut]) error
}

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

type ResponseBodyService_GetResponseBodyStreamClient ¶

type ResponseBodyService_GetResponseBodyStreamClient = grpc.ServerStreamingClient[ResponseBodyOut]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type ResponseBodyService_GetResponseBodyStreamServer ¶

type ResponseBodyService_GetResponseBodyStreamServer = grpc.ServerStreamingServer[ResponseBodyOut]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

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.

ServiceA provides MethodOne and MethodTwo

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.

ServiceA provides MethodOne and MethodTwo

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.

ServiceB service responds to incoming merge requests.

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.

ServiceB service responds to incoming merge requests.

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.

ServiceC service responds to incoming merge requests.

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.

ServiceC service responds to incoming merge requests.

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"`
	ResourceId string              `protobuf:"bytes,8,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
	NId        *NestedMessage      `protobuf:"bytes,9,opt,name=n_id,json=nId,proto3" json:"n_id,omitempty"`
	// contains filtered or unexported fields
}

SimpleMessage represents a simple message sent to the Echo service.

func (*SimpleMessage) Descriptor ¶

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) GetNId ¶

func (x *SimpleMessage) GetNId() *NestedMessage

func (*SimpleMessage) GetNo ¶

func (x *SimpleMessage) GetNo() *Embedded

func (*SimpleMessage) GetNum ¶

func (x *SimpleMessage) GetNum() int64

func (*SimpleMessage) GetResourceId ¶

func (x *SimpleMessage) GetResourceId() string

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 ¶

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 ¶

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 ¶

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               `protobuf:"varint,1,opt,name=what,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.SnakeCaseEnum" json:"what,omitempty"`
	Who   SnakeCase_0Enum             `protobuf:"varint,2,opt,name=who,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.SnakeCase_0Enum" json:"who,omitempty"`
	Where pathenum.SnakeCaseForImport `protobuf:"varint,3,opt,name=where,proto3,enum=grpc.gateway.examples.internal.pathenum.SnakeCaseForImport" json:"where,omitempty"`
	// contains filtered or unexported fields
}

func (*SnakeEnumRequest) Descriptor ¶

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 ¶

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) (grpc.ClientStreamingClient[ABitOfEverything, emptypb.Empty], error)
	List(ctx context.Context, in *Options, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ABitOfEverything], error)
	BulkEcho(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[sub.StringMessage, sub.StringMessage], error)
	BulkEchoDuration(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[durationpb.Duration, durationpb.Duration], error)
	Download(ctx context.Context, in *Options, opts ...grpc.CallOption) (grpc.ServerStreamingClient[httpbody.HttpBody], 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.

Defines some more operations to be added to ABitOfEverythingService

func NewStreamServiceClient ¶

func NewStreamServiceClient(cc grpc.ClientConnInterface) StreamServiceClient

type StreamServiceServer ¶

type StreamServiceServer interface {
	BulkCreate(grpc.ClientStreamingServer[ABitOfEverything, emptypb.Empty]) error
	List(*Options, grpc.ServerStreamingServer[ABitOfEverything]) error
	BulkEcho(grpc.BidiStreamingServer[sub.StringMessage, sub.StringMessage]) error
	BulkEchoDuration(grpc.BidiStreamingServer[durationpb.Duration, durationpb.Duration]) error
	Download(*Options, grpc.ServerStreamingServer[httpbody.HttpBody]) error
}

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

Defines some more operations to be added to ABitOfEverythingService

type StreamService_BulkCreateClient ¶

type StreamService_BulkCreateClient = grpc.ClientStreamingClient[ABitOfEverything, emptypb.Empty]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_BulkCreateServer ¶

type StreamService_BulkCreateServer = grpc.ClientStreamingServer[ABitOfEverything, emptypb.Empty]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_BulkEchoClient ¶

type StreamService_BulkEchoClient = grpc.BidiStreamingClient[sub.StringMessage, sub.StringMessage]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_BulkEchoDurationClient ¶

type StreamService_BulkEchoDurationClient = grpc.BidiStreamingClient[durationpb.Duration, durationpb.Duration]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_BulkEchoDurationServer ¶

type StreamService_BulkEchoDurationServer = grpc.BidiStreamingServer[durationpb.Duration, durationpb.Duration]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_BulkEchoServer ¶

type StreamService_BulkEchoServer = grpc.BidiStreamingServer[sub.StringMessage, sub.StringMessage]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_DownloadClient ¶

type StreamService_DownloadClient = grpc.ServerStreamingClient[httpbody.HttpBody]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_DownloadServer ¶

type StreamService_DownloadServer = grpc.ServerStreamingServer[httpbody.HttpBody]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_ListClient ¶

type StreamService_ListClient = grpc.ServerStreamingClient[ABitOfEverything]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

type StreamService_ListServer ¶

type StreamService_ListServer = grpc.ServerStreamingServer[ABitOfEverything]

This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.

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.

Echo service responds to incoming echo requests.

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.

Echo service responds to incoming echo requests.

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 ¶

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 UnannotatedNestedMessage ¶

type UnannotatedNestedMessage struct {
	NId string `protobuf:"bytes,1,opt,name=n_id,json=nId,proto3" json:"n_id,omitempty"`
	Val string `protobuf:"bytes,2,opt,name=val,proto3" json:"val,omitempty"`
	// contains filtered or unexported fields
}

func (*UnannotatedNestedMessage) Descriptor ¶

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

Deprecated: Use UnannotatedNestedMessage.ProtoReflect.Descriptor instead.

func (*UnannotatedNestedMessage) GetNId ¶

func (x *UnannotatedNestedMessage) GetNId() string

func (*UnannotatedNestedMessage) GetVal ¶

func (x *UnannotatedNestedMessage) GetVal() string

func (*UnannotatedNestedMessage) ProtoMessage ¶

func (*UnannotatedNestedMessage) ProtoMessage()

func (*UnannotatedNestedMessage) ProtoReflect ¶

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

func (*UnannotatedNestedMessage) Reset ¶

func (x *UnannotatedNestedMessage) Reset()

func (*UnannotatedNestedMessage) String ¶

func (x *UnannotatedNestedMessage) String() string

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"`
	ResourceId string                         `protobuf:"bytes,9,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
	NId        *UnannotatedNestedMessage      `protobuf:"bytes,10,opt,name=n_id,json=nId,proto3" json:"n_id,omitempty"`
	// contains filtered or unexported fields
}

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

func (*UnannotatedSimpleMessage) Descriptor ¶

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) GetNId ¶

func (x *UnannotatedSimpleMessage) GetNId() *UnannotatedNestedMessage

func (*UnannotatedSimpleMessage) GetNo ¶

func (x *UnannotatedSimpleMessage) GetNo() *UnannotatedEmbedded

func (*UnannotatedSimpleMessage) GetNum ¶

func (x *UnannotatedSimpleMessage) GetNum() int64

func (*UnannotatedSimpleMessage) GetResourceId ¶

func (x *UnannotatedSimpleMessage) GetResourceId() string

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 ¶

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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) OverwriteRequestContentType ¶

func (UnimplementedABitOfEverythingServiceServer) OverwriteRequestContentType(context.Context, *Body) (*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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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 UnimplementedEnumWithSingleValueServiceServer ¶

type UnimplementedEnumWithSingleValueServiceServer struct{}

UnimplementedEnumWithSingleValueServiceServer should be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedEnumWithSingleValueServiceServer) Echo ¶

func (UnimplementedEnumWithSingleValueServiceServer) Echo(context.Context, *EnumWithSingleValueServiceEchoRequest) (*EnumWithSingleValueServiceEchoResponse, error)

type UnimplementedFlowCombinationServer ¶

type UnimplementedFlowCombinationServer struct{}

UnimplementedFlowCombinationServer should be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedFlowCombinationServer) RpcBodyRpc ¶

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

func (UnimplementedFlowCombinationServer) RpcBodyStream ¶

func (UnimplementedFlowCombinationServer) RpcBodyStream(*NonEmptyProto, grpc.ServerStreamingServer[EmptyProto]) error

func (UnimplementedFlowCombinationServer) RpcEmptyRpc ¶

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

func (UnimplementedFlowCombinationServer) RpcEmptyStream ¶

func (UnimplementedFlowCombinationServer) RpcEmptyStream(*EmptyProto, grpc.ServerStreamingServer[EmptyProto]) error

func (UnimplementedFlowCombinationServer) RpcPathNestedRpc ¶

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

func (UnimplementedFlowCombinationServer) RpcPathNestedStream ¶

func (UnimplementedFlowCombinationServer) RpcPathNestedStream(*NestedProto, grpc.ServerStreamingServer[EmptyProto]) error

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedRpc ¶

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

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedStream ¶

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedStream(*SingleNestedProto, grpc.ServerStreamingServer[EmptyProto]) error

func (UnimplementedFlowCombinationServer) StreamEmptyRpc ¶

func (UnimplementedFlowCombinationServer) StreamEmptyRpc(grpc.ClientStreamingServer[EmptyProto, EmptyProto]) error

func (UnimplementedFlowCombinationServer) StreamEmptyStream ¶

func (UnimplementedFlowCombinationServer) StreamEmptyStream(grpc.BidiStreamingServer[EmptyProto, EmptyProto]) error

type UnimplementedFoo2ServiceServer ¶

type UnimplementedFoo2ServiceServer struct{}

UnimplementedFoo2ServiceServer should be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedFoo2ServiceServer) Foo2 ¶

func (UnimplementedFoo2ServiceServer) Foo2(context.Context, *Foo2Request) (*Foo2Reply, error)

type UnimplementedFooServiceServer ¶

type UnimplementedFooServiceServer struct{}

UnimplementedFooServiceServer should be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedFooServiceServer) Foo ¶

func (UnimplementedFooServiceServer) Foo(context.Context, *FooRequest) (*FooReply, error)

type UnimplementedGenerateUnboundMethodsEchoServiceServer ¶

type UnimplementedGenerateUnboundMethodsEchoServiceServer struct{}

UnimplementedGenerateUnboundMethodsEchoServiceServer should be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedResponseBodyServiceServer) GetResponseBody ¶

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

func (UnimplementedResponseBodyServiceServer) GetResponseBodyStream ¶

func (UnimplementedResponseBodyServiceServer) GetResponseBodyStream(*ResponseBodyIn, grpc.ServerStreamingServer[ResponseBodyOut]) 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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

func (UnimplementedStreamServiceServer) BulkCreate ¶

func (UnimplementedStreamServiceServer) BulkCreate(grpc.ClientStreamingServer[ABitOfEverything, emptypb.Empty]) error

func (UnimplementedStreamServiceServer) BulkEcho ¶

func (UnimplementedStreamServiceServer) BulkEcho(grpc.BidiStreamingServer[sub.StringMessage, sub.StringMessage]) error

func (UnimplementedStreamServiceServer) BulkEchoDuration ¶

func (UnimplementedStreamServiceServer) BulkEchoDuration(grpc.BidiStreamingServer[durationpb.Duration, durationpb.Duration]) error

func (UnimplementedStreamServiceServer) Download ¶

func (UnimplementedStreamServiceServer) Download(*Options, grpc.ServerStreamingServer[httpbody.HttpBody]) error

func (UnimplementedStreamServiceServer) List ¶

func (UnimplementedStreamServiceServer) List(*Options, grpc.ServerStreamingServer[ABitOfEverything]) error

type UnimplementedUnannotatedEchoServiceServer ¶

type UnimplementedUnannotatedEchoServiceServer struct{}

UnimplementedUnannotatedEchoServiceServer should be embedded to have forward compatible implementations.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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.

NOTE: this should be embedded by value instead of pointer to avoid a nil pointer dereference when methods are called.

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 UnsafeEnumWithSingleValueServiceServer ¶

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

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

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

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

type UnsafeFooServiceServer ¶

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

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

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 ¶

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.

VisibilityRuleEchoService service responds to incoming echo requests. Different services will be available in the swagger documentation depending based on `google.api.VisibilityRule`s and the set `visibility_restriction_selectors` flag when calling protoc-gen-openapiv2.

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 ¶

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 ¶

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.

VisibilityRuleInternalEchoService service responds to incoming echo requests. It should only be visible in the OpenAPI spec if `visibility_restriction_selectors` includes "INTERNAL".

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.

VisibilityRuleInternalEchoService service responds to incoming echo requests. It should only be visible in the OpenAPI spec if `visibility_restriction_selectors` includes "INTERNAL".

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        `protobuf:"varint,3,opt,name=enum,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleEnumInPreviewMethod" json:"enum,omitempty"`
	// 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 ¶

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              `protobuf:"varint,10,opt,name=an_enum,json=anEnum,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleSimpleMessage_VisibilityEnum" json:"an_enum,omitempty"`
	AhiddenDefaultEnum VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault `protobuf:"varint,11,opt,name=ahidden_default_enum,json=ahiddenDefaultEnum,proto3,enum=grpc.gateway.examples.internal.proto.examplepb.VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault" json:"ahidden_default_enum,omitempty"`
	// contains filtered or unexported fields
}

SimpleMessage represents a simple message sent to the Echo service.

func (*VisibilityRuleSimpleMessage) Descriptor ¶

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

Deprecated: Use VisibilityRuleSimpleMessage.ProtoReflect.Descriptor instead.

func (*VisibilityRuleSimpleMessage) GetAhiddenDefaultEnum ¶

func (x *VisibilityRuleSimpleMessage) GetAhiddenDefaultEnum() VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault

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 ¶

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 VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault ¶

type VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault int32

const (
	VisibilityRuleSimpleMessage_VISIBILITY_ENUM_HIDDEN_DEFAULT_UNSPECIFIED VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault = 0
	VisibilityRuleSimpleMessage_VISIBILITY_ENUM_HIDDEN_DEFAULT_VISIBLE     VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault = 1
)

func (VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) Descriptor ¶

func (VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) Descriptor() protoreflect.EnumDescriptor

func (VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) Enum ¶

func (x VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) Enum() *VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault

func (VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) EnumDescriptor ¶

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

Deprecated: Use VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault.Descriptor instead.

func (VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) Number ¶

func (x VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) Number() protoreflect.EnumNumber

func (VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) String ¶

func (x VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) String() string

func (VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) Type ¶

func (VisibilityRuleSimpleMessage_VisibilityEnumHiddenDefault) 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 ¶

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 ¶

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 ¶

a_bit_of_everything.pb.go a_bit_of_everything.pb.gw.go a_bit_of_everything_grpc.pb.go echo_service.pb.go echo_service.pb.gw.go echo_service_grpc.pb.go enum_with_single_value.pb.go enum_with_single_value.pb.gw.go enum_with_single_value_grpc.pb.go flow_combination.pb.go flow_combination.pb.gw.go flow_combination_grpc.pb.go generate_unbound_methods.pb.go generate_unbound_methods.pb.gw.go generate_unbound_methods_grpc.pb.go ignore_comment.pb.go ignore_comment.pb.gw.go ignore_comment_grpc.pb.go non_standard_names.pb.go non_standard_names.pb.gw.go non_standard_names_grpc.pb.go openapi_merge_a.pb.go openapi_merge_a.pb.gw.go openapi_merge_a_grpc.pb.go openapi_merge_b.pb.go openapi_merge_b.pb.gw.go openapi_merge_b_grpc.pb.go remove_internal_comment.pb.go remove_internal_comment.pb.gw.go remove_internal_comment_grpc.pb.go response_body_service.pb.go response_body_service.pb.gw.go response_body_service_grpc.pb.go stream.pb.go stream.pb.gw.go stream_grpc.pb.go unannotated_echo_service.pb.go unannotated_echo_service.pb.gw.go unannotated_echo_service_grpc.pb.go use_go_template.pb.go use_go_template.pb.gw.go use_go_template_grpc.pb.go visibility_rule_echo_service.pb.go visibility_rule_echo_service.pb.gw.go visibility_rule_echo_service_grpc.pb.go wrappers.pb.go wrappers.pb.gw.go wrappers_grpc.pb.go

Version: v2.26.1 (latest)
Published: Feb 7, 2025
Platform: linux/amd64
Imports: 31 packages
Last checked: 6 days ago –

Tools for package owners.

?	: This menu
/	: Search site
f	: Jump to identifier
g then g	: Go to top of page
g then b	: Go to end of page
G	: Go to end of page
g then i	: Go to index
g then e	: Go to examples