▽

Package examplepb

Variables ¶

Enum value maps for NumericEnum.

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

Enum value maps for SnakeCaseEnum.

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 SnakeCase_0Enum.

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 ABitOfEverything_Nested_DeepEnum.

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 RepeatedResponseBodyOut_Response_ResponseType.

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 VisibilityRuleEnumInPreviewMethod.

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 VisibilityRuleSimpleMessage_VisibilityEnum.

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,
    }
)

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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_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

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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 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",
}

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

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 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",
}

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 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",
}

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 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",
}

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)

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",
}

func RegisterABitOfEverythingServiceHandler ¶

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

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

func RegisterABitOfEverythingServiceHandlerClient ¶

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

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

func RegisterABitOfEverythingServiceHandlerFromEndpoint ¶

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

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

func RegisterABitOfEverythingServiceHandlerServer ¶

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

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

func RegisterABitOfEverythingServiceServer ¶

func RegisterABitOfEverythingServiceServer(s grpc.ServiceRegistrar, srv ABitOfEverythingServiceServer)

func RegisterAnotherServiceWithNoBindingsServer ¶

func RegisterAnotherServiceWithNoBindingsServer(s grpc.ServiceRegistrar, srv AnotherServiceWithNoBindingsServer)

func RegisterCamelCaseServiceNameHandler ¶

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

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

func RegisterCamelCaseServiceNameHandlerClient ¶

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

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

func RegisterCamelCaseServiceNameHandlerFromEndpoint ¶

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

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

func RegisterCamelCaseServiceNameHandlerServer ¶

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

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

func RegisterCamelCaseServiceNameServer ¶

func RegisterCamelCaseServiceNameServer(s grpc.ServiceRegistrar, srv CamelCaseServiceNameServer)

func RegisterEchoServiceHandler ¶

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

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

func RegisterEchoServiceHandlerClient ¶

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

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

func RegisterEchoServiceHandlerFromEndpoint ¶

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

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

func RegisterEchoServiceHandlerServer ¶

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

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

func RegisterEchoServiceServer ¶

func RegisterEchoServiceServer(s grpc.ServiceRegistrar, srv EchoServiceServer)

func RegisterFlowCombinationHandler ¶

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

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

func RegisterFlowCombinationHandlerClient ¶

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

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

func RegisterFlowCombinationHandlerFromEndpoint ¶

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

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

func RegisterFlowCombinationHandlerServer ¶

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

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

func RegisterFlowCombinationServer ¶

func RegisterFlowCombinationServer(s grpc.ServiceRegistrar, srv FlowCombinationServer)

func 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.

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.

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.

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.

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.

func RegisterGenerateUnboundMethodsEchoServiceHandlerFromEndpoint ¶

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

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

func RegisterGenerateUnboundMethodsEchoServiceHandlerServer ¶

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

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

func RegisterGenerateUnboundMethodsEchoServiceServer ¶

func RegisterGenerateUnboundMethodsEchoServiceServer(s grpc.ServiceRegistrar, srv GenerateUnboundMethodsEchoServiceServer)

func RegisterLoginServiceHandler ¶

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

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

func RegisterLoginServiceHandlerClient ¶

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

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

func RegisterLoginServiceHandlerFromEndpoint ¶

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

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

func RegisterLoginServiceHandlerServer ¶

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

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

func RegisterLoginServiceServer ¶

func RegisterLoginServiceServer(s grpc.ServiceRegistrar, srv LoginServiceServer)

func RegisterNonStandardServiceHandler ¶

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

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

func RegisterNonStandardServiceHandlerClient ¶

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

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

func RegisterNonStandardServiceHandlerFromEndpoint ¶

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

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

func RegisterNonStandardServiceHandlerServer ¶

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

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

func RegisterNonStandardServiceServer ¶

func RegisterNonStandardServiceServer(s grpc.ServiceRegistrar, srv NonStandardServiceServer)

func RegisterResponseBodyServiceHandler ¶

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

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

func RegisterResponseBodyServiceHandlerClient ¶

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

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

func RegisterResponseBodyServiceHandlerFromEndpoint ¶

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

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

func RegisterResponseBodyServiceHandlerServer ¶

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

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

func RegisterResponseBodyServiceServer ¶

func RegisterResponseBodyServiceServer(s grpc.ServiceRegistrar, srv ResponseBodyServiceServer)

func RegisterServiceAHandler ¶

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

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

func RegisterServiceAHandlerClient ¶

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

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

func RegisterServiceAHandlerFromEndpoint ¶

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

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

func RegisterServiceAHandlerServer ¶

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

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

func RegisterServiceAServer ¶

func RegisterServiceAServer(s grpc.ServiceRegistrar, srv ServiceAServer)

func RegisterServiceBHandler ¶

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

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

func RegisterServiceBHandlerClient ¶

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

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

func RegisterServiceBHandlerFromEndpoint ¶

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

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

func RegisterServiceBHandlerServer ¶

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

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

func RegisterServiceBServer ¶

func RegisterServiceBServer(s grpc.ServiceRegistrar, srv ServiceBServer)

func RegisterServiceCHandler ¶

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

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

func RegisterServiceCHandlerClient ¶

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

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

func RegisterServiceCHandlerFromEndpoint ¶

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

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

func RegisterServiceCHandlerServer ¶

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

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

func RegisterServiceCServer ¶

func RegisterServiceCServer(s grpc.ServiceRegistrar, srv ServiceCServer)

func RegisterSnakeEnumServiceHandler ¶

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

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

func RegisterSnakeEnumServiceHandlerClient ¶

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

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

func RegisterSnakeEnumServiceHandlerFromEndpoint ¶

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

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

func RegisterSnakeEnumServiceHandlerServer ¶

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

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

func RegisterSnakeEnumServiceServer ¶

func RegisterSnakeEnumServiceServer(s grpc.ServiceRegistrar, srv SnakeEnumServiceServer)

func RegisterStreamServiceHandler ¶

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

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

func RegisterStreamServiceHandlerClient ¶

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

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

func RegisterStreamServiceHandlerFromEndpoint ¶

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

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

func RegisterStreamServiceHandlerServer ¶

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

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

func RegisterStreamServiceServer ¶

func RegisterStreamServiceServer(s grpc.ServiceRegistrar, srv StreamServiceServer)

func RegisterUnannotatedEchoServiceHandler ¶

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

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

func RegisterUnannotatedEchoServiceHandlerClient ¶

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

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

func RegisterUnannotatedEchoServiceHandlerFromEndpoint ¶

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

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

func RegisterUnannotatedEchoServiceHandlerServer ¶

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

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

func RegisterUnannotatedEchoServiceServer ¶

func RegisterUnannotatedEchoServiceServer(s grpc.ServiceRegistrar, srv UnannotatedEchoServiceServer)

func RegisterVisibilityRuleEchoServiceHandler ¶

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

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

func RegisterVisibilityRuleEchoServiceHandlerClient ¶

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

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

func RegisterVisibilityRuleEchoServiceHandlerFromEndpoint ¶

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

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

func RegisterVisibilityRuleEchoServiceHandlerServer ¶

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

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

func RegisterVisibilityRuleEchoServiceServer ¶

func RegisterVisibilityRuleEchoServiceServer(s grpc.ServiceRegistrar, srv VisibilityRuleEchoServiceServer)

func RegisterVisibilityRuleInternalEchoServiceHandler ¶

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

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

func RegisterVisibilityRuleInternalEchoServiceHandlerClient ¶

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

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

func RegisterVisibilityRuleInternalEchoServiceHandlerFromEndpoint ¶

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

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

func RegisterVisibilityRuleInternalEchoServiceHandlerServer ¶

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

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

func RegisterVisibilityRuleInternalEchoServiceServer ¶

func RegisterVisibilityRuleInternalEchoServiceServer(s grpc.ServiceRegistrar, srv VisibilityRuleInternalEchoServiceServer)

func RegisterWrappersServiceHandler ¶

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

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

func RegisterWrappersServiceHandlerClient ¶

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

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

func RegisterWrappersServiceHandlerFromEndpoint ¶

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

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

func RegisterWrappersServiceHandlerServer ¶

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

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

func RegisterWrappersServiceServer ¶

func RegisterWrappersServiceServer(s grpc.ServiceRegistrar, srv WrappersServiceServer)

type ABitOfEverything ¶

Intentionally complicated message type to cover many features of Protobuf.

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"`
    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"`
    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
}

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 ¶

ABitOfEverythingRepeated is used to validate repeated path parameter functionality

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
}

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 ¶

ABitOfEverythingServiceClient is the client API for ABitOfEverythingService service.

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

type 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)
}

func NewABitOfEverythingServiceClient ¶

func NewABitOfEverythingServiceClient(cc grpc.ClientConnInterface) ABitOfEverythingServiceClient

type ABitOfEverythingServiceServer ¶

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

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

type ABitOfEverything_Nested ¶

Nested is nested type.

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
}

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 ¶

DeepEnum is one or zero.

type ABitOfEverything_Nested_DeepEnum int32

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 ¶

AnotherServiceWithNoBindingsClient is the client API for AnotherServiceWithNoBindings service.

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

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

func NewAnotherServiceWithNoBindingsClient ¶

func NewAnotherServiceWithNoBindingsClient(cc grpc.ClientConnInterface) AnotherServiceWithNoBindingsClient

type AnotherServiceWithNoBindingsServer ¶

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

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

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 ¶

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

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

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
}

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 ¶

CamelCaseServiceNameClient is the client API for CamelCaseServiceName service.

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

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

func NewCamelCaseServiceNameClient ¶

func NewCamelCaseServiceNameClient(cc grpc.ClientConnInterface) CamelCaseServiceNameClient

type CamelCaseServiceNameServer ¶

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

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

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 ¶

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

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
}

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 ¶

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

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
}

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 ¶

EchoServiceClient is the client API for EchoService service.

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

type 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)
}

func NewEchoServiceClient ¶

func NewEchoServiceClient(cc grpc.ClientConnInterface) EchoServiceClient

type EchoServiceServer ¶

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

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

type Embedded ¶

Embedded represents a message embedded in SimpleMessage.

type Embedded struct {

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

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

FlowCombinationClient is the client API for FlowCombination service.

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

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

func NewFlowCombinationClient ¶

func NewFlowCombinationClient(cc grpc.ClientConnInterface) FlowCombinationClient

type FlowCombinationServer ¶

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

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

type FlowCombination_RpcBodyStreamClient ¶

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

type FlowCombination_RpcBodyStreamServer ¶

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

type FlowCombination_RpcEmptyStreamClient ¶

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

type FlowCombination_RpcEmptyStreamServer ¶

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

type FlowCombination_RpcPathNestedStreamClient ¶

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

type FlowCombination_RpcPathNestedStreamServer ¶

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

type FlowCombination_RpcPathSingleNestedStreamClient ¶

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

type FlowCombination_RpcPathSingleNestedStreamServer ¶

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

type FlowCombination_StreamEmptyRpcClient ¶

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

type FlowCombination_StreamEmptyRpcServer ¶

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

type FlowCombination_StreamEmptyStreamClient ¶

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

type FlowCombination_StreamEmptyStreamServer ¶

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

type Foo ¶

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

func (*Foo) Descriptor ¶

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 ¶

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

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

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 ¶

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

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
}

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 ¶

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.

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

func NewFoo2ServiceClient ¶

func NewFoo2ServiceClient(cc grpc.ClientConnInterface) Foo2ServiceClient

type Foo2ServiceServer ¶

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

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

type FooReply ¶

This comment should be excluded from OpenAPI output

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

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 ¶

This comment should be excluded from OpenAPI output

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
}

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 ¶

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.

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

func NewFooServiceClient ¶

func NewFooServiceClient(cc grpc.ClientConnInterface) FooServiceClient

type FooServiceServer ¶

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

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

type GenerateUnboundMethodsEchoServiceClient ¶

GenerateUnboundMethodsEchoServiceClient is the client API for GenerateUnboundMethodsEchoService service.

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

type 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)
}

func NewGenerateUnboundMethodsEchoServiceClient ¶

func NewGenerateUnboundMethodsEchoServiceClient(cc grpc.ClientConnInterface) GenerateUnboundMethodsEchoServiceClient

type GenerateUnboundMethodsEchoServiceServer ¶

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

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

type GenerateUnboundMethodsSimpleMessage ¶

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

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
}

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 ¶

InMessageA represents a message to ServiceA and ServiceC.

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
}

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 ¶

InMessageB represents a message to ServiceB.

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
}

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 ¶

LoginServiceClient is the client API for LoginService service.

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

type 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)
}

func NewLoginServiceClient ¶

func NewLoginServiceClient(cc grpc.ClientConnInterface) LoginServiceClient

type LoginServiceServer ¶

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

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

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 [] infront 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 ¶

NonStandardMessage has oddly named fields.

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
}

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 ¶

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

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
}

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 ¶

NonStandardServiceClient is the client API for NonStandardService service.

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

type 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)
}

func NewNonStandardServiceClient ¶

func NewNonStandardServiceClient(cc grpc.ClientConnInterface) NonStandardServiceClient

type NonStandardServiceServer ¶

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

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

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 ¶

NumericEnum is one or zero.

type NumericEnum int32

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 ¶

OutMessageA represents a message returned from ServiceA.

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
}

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 ¶

OutMessageB represents a message returned from ServiceB.

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
}

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 ¶

OutMessageC represents a message returned from ServiceC.

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
}

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 ¶

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

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
}

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 ¶

ResponseBodyServiceClient is the client API for ResponseBodyService service.

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

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

func NewResponseBodyServiceClient ¶

func NewResponseBodyServiceClient(cc grpc.ClientConnInterface) ResponseBodyServiceClient

type ResponseBodyServiceServer ¶

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

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

type ResponseBodyService_GetResponseBodyStreamClient ¶

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

type ResponseBodyService_GetResponseBodyStreamServer ¶

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

type ServiceAClient ¶

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.

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

func NewServiceAClient ¶

func NewServiceAClient(cc grpc.ClientConnInterface) ServiceAClient

type ServiceAServer ¶

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

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

type ServiceBClient ¶

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.

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

func NewServiceBClient ¶

func NewServiceBClient(cc grpc.ClientConnInterface) ServiceBClient

type ServiceBServer ¶

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

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

type ServiceCClient ¶

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.

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

func NewServiceCClient ¶

func NewServiceCClient(cc grpc.ClientConnInterface) ServiceCClient

type ServiceCServer ¶

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

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

type SimpleMessage ¶

SimpleMessage represents a simple message sent to the Echo service.

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
}

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 ¶

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

type SnakeCaseEnum int32

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 ¶

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

type SnakeCase_0Enum int32

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 ¶

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.

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

func NewSnakeEnumServiceClient ¶

func NewSnakeEnumServiceClient(cc grpc.ClientConnInterface) SnakeEnumServiceClient

type SnakeEnumServiceServer ¶

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

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

type StreamServiceClient ¶

StreamServiceClient is the client API for StreamService service.

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

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

func NewStreamServiceClient ¶

func NewStreamServiceClient(cc grpc.ClientConnInterface) StreamServiceClient

type StreamServiceServer ¶

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

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

type StreamService_BulkCreateClient ¶

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

type StreamService_BulkCreateServer ¶

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

type StreamService_BulkEchoClient ¶

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

type StreamService_BulkEchoServer ¶

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

type StreamService_DownloadClient ¶

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

type StreamService_DownloadServer ¶

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

type StreamService_ListClient ¶

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

type StreamService_ListServer ¶

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

type UnannotatedEchoServiceClient ¶

UnannotatedEchoServiceClient is the client API for UnannotatedEchoService service.

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

type 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)
}

func NewUnannotatedEchoServiceClient ¶

func NewUnannotatedEchoServiceClient(cc grpc.ClientConnInterface) UnannotatedEchoServiceClient

type UnannotatedEchoServiceServer ¶

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

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

type UnannotatedEmbedded ¶

Embedded represents a message embedded in SimpleMessage.

type UnannotatedEmbedded struct {

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

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 ¶

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

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
}

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 ¶

UnimplementedABitOfEverythingServiceServer should be embedded to have forward compatible implementations.

type UnimplementedABitOfEverythingServiceServer struct {
}

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 ¶

UnimplementedAnotherServiceWithNoBindingsServer should be embedded to have forward compatible implementations.

type UnimplementedAnotherServiceWithNoBindingsServer struct {
}

func (UnimplementedAnotherServiceWithNoBindingsServer) NoBindings ¶

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

type UnimplementedCamelCaseServiceNameServer ¶

UnimplementedCamelCaseServiceNameServer should be embedded to have forward compatible implementations.

type UnimplementedCamelCaseServiceNameServer struct {
}

func (UnimplementedCamelCaseServiceNameServer) Empty ¶

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

type UnimplementedEchoServiceServer ¶

UnimplementedEchoServiceServer should be embedded to have forward compatible implementations.

type UnimplementedEchoServiceServer struct {
}

func (UnimplementedEchoServiceServer) Echo ¶

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

func (UnimplementedEchoServiceServer) EchoBody ¶

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

func (UnimplementedEchoServiceServer) EchoDelete ¶

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

func (UnimplementedEchoServiceServer) EchoPatch ¶

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

func (UnimplementedEchoServiceServer) EchoUnauthorized ¶

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

type UnimplementedFlowCombinationServer ¶

UnimplementedFlowCombinationServer should be embedded to have forward compatible implementations.

type UnimplementedFlowCombinationServer struct {
}

func (UnimplementedFlowCombinationServer) RpcBodyRpc ¶

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

func (UnimplementedFlowCombinationServer) RpcBodyStream ¶

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

func (UnimplementedFlowCombinationServer) RpcEmptyRpc ¶

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

func (UnimplementedFlowCombinationServer) RpcEmptyStream ¶

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

func (UnimplementedFlowCombinationServer) RpcPathNestedRpc ¶

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

func (UnimplementedFlowCombinationServer) RpcPathNestedStream ¶

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

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedRpc ¶

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

func (UnimplementedFlowCombinationServer) RpcPathSingleNestedStream ¶

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

func (UnimplementedFlowCombinationServer) StreamEmptyRpc ¶

func (UnimplementedFlowCombinationServer) StreamEmptyRpc(FlowCombination_StreamEmptyRpcServer) error

func (UnimplementedFlowCombinationServer) StreamEmptyStream ¶

func (UnimplementedFlowCombinationServer) StreamEmptyStream(FlowCombination_StreamEmptyStreamServer) error

type UnimplementedFoo2ServiceServer ¶

UnimplementedFoo2ServiceServer should be embedded to have forward compatible implementations.

type UnimplementedFoo2ServiceServer struct {
}

func (UnimplementedFoo2ServiceServer) Foo2 ¶

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

type UnimplementedFooServiceServer ¶

UnimplementedFooServiceServer should be embedded to have forward compatible implementations.

type UnimplementedFooServiceServer struct {
}

func (UnimplementedFooServiceServer) Foo ¶

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

type UnimplementedGenerateUnboundMethodsEchoServiceServer ¶

UnimplementedGenerateUnboundMethodsEchoServiceServer should be embedded to have forward compatible implementations.

type UnimplementedGenerateUnboundMethodsEchoServiceServer struct {
}

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 ¶

UnimplementedLoginServiceServer should be embedded to have forward compatible implementations.

type UnimplementedLoginServiceServer struct {
}

func (UnimplementedLoginServiceServer) Login ¶

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

func (UnimplementedLoginServiceServer) Logout ¶

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

type UnimplementedNonStandardServiceServer ¶

UnimplementedNonStandardServiceServer should be embedded to have forward compatible implementations.

type UnimplementedNonStandardServiceServer struct {
}

func (UnimplementedNonStandardServiceServer) Update ¶

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

func (UnimplementedNonStandardServiceServer) UpdateWithJSONNames ¶

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

type UnimplementedResponseBodyServiceServer ¶

UnimplementedResponseBodyServiceServer should be embedded to have forward compatible implementations.

type UnimplementedResponseBodyServiceServer struct {
}

func (UnimplementedResponseBodyServiceServer) GetResponseBody ¶

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

func (UnimplementedResponseBodyServiceServer) GetResponseBodyStream ¶

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

func (UnimplementedResponseBodyServiceServer) ListResponseBodies ¶

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

func (UnimplementedResponseBodyServiceServer) ListResponseStrings ¶

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

type UnimplementedServiceAServer ¶

UnimplementedServiceAServer should be embedded to have forward compatible implementations.

type UnimplementedServiceAServer struct {
}

func (UnimplementedServiceAServer) MethodOne ¶

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

func (UnimplementedServiceAServer) MethodTwo ¶

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

type UnimplementedServiceBServer ¶

UnimplementedServiceBServer should be embedded to have forward compatible implementations.

type UnimplementedServiceBServer struct {
}

func (UnimplementedServiceBServer) MethodOne ¶

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

func (UnimplementedServiceBServer) MethodTwo ¶

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

type UnimplementedServiceCServer ¶

UnimplementedServiceCServer should be embedded to have forward compatible implementations.

type UnimplementedServiceCServer struct {
}

func (UnimplementedServiceCServer) MethodOne ¶

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

func (UnimplementedServiceCServer) MethodTwo ¶

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

type UnimplementedSnakeEnumServiceServer ¶

UnimplementedSnakeEnumServiceServer should be embedded to have forward compatible implementations.

type UnimplementedSnakeEnumServiceServer struct {
}

func (UnimplementedSnakeEnumServiceServer) SnakeEnum ¶

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

type UnimplementedStreamServiceServer ¶

UnimplementedStreamServiceServer should be embedded to have forward compatible implementations.

type UnimplementedStreamServiceServer struct {
}

func (UnimplementedStreamServiceServer) BulkCreate ¶

func (UnimplementedStreamServiceServer) BulkCreate(StreamService_BulkCreateServer) error

func (UnimplementedStreamServiceServer) BulkEcho ¶

func (UnimplementedStreamServiceServer) BulkEcho(StreamService_BulkEchoServer) error

func (UnimplementedStreamServiceServer) Download ¶

func (UnimplementedStreamServiceServer) Download(*Options, StreamService_DownloadServer) error

func (UnimplementedStreamServiceServer) List ¶

func (UnimplementedStreamServiceServer) List(*Options, StreamService_ListServer) error

type UnimplementedUnannotatedEchoServiceServer ¶

UnimplementedUnannotatedEchoServiceServer should be embedded to have forward compatible implementations.

type UnimplementedUnannotatedEchoServiceServer struct {
}

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 ¶

UnimplementedVisibilityRuleEchoServiceServer should be embedded to have forward compatible implementations.

type UnimplementedVisibilityRuleEchoServiceServer struct {
}

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 ¶

UnimplementedVisibilityRuleInternalEchoServiceServer should be embedded to have forward compatible implementations.

type UnimplementedVisibilityRuleInternalEchoServiceServer struct {
}

func (UnimplementedVisibilityRuleInternalEchoServiceServer) Echo ¶

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

type UnimplementedWrappersServiceServer ¶

UnimplementedWrappersServiceServer should be embedded to have forward compatible implementations.

type UnimplementedWrappersServiceServer struct {
}

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 ¶

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 UnsafeABitOfEverythingServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeAnotherServiceWithNoBindingsServer ¶

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 UnsafeAnotherServiceWithNoBindingsServer interface {
    // contains filtered or unexported methods
}

type UnsafeCamelCaseServiceNameServer ¶

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 UnsafeCamelCaseServiceNameServer interface {
    // contains filtered or unexported methods
}

type UnsafeEchoServiceServer ¶

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 UnsafeEchoServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeFlowCombinationServer ¶

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 UnsafeFlowCombinationServer interface {
    // contains filtered or unexported methods
}

type UnsafeFoo2ServiceServer ¶

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 UnsafeFoo2ServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeFooServiceServer ¶

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 UnsafeFooServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeGenerateUnboundMethodsEchoServiceServer ¶

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 UnsafeGenerateUnboundMethodsEchoServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeLoginServiceServer ¶

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 UnsafeLoginServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeNonStandardServiceServer ¶

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 UnsafeNonStandardServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeResponseBodyServiceServer ¶

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 UnsafeResponseBodyServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeServiceAServer ¶

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 UnsafeServiceAServer interface {
    // contains filtered or unexported methods
}

type UnsafeServiceBServer ¶

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 UnsafeServiceBServer interface {
    // contains filtered or unexported methods
}

type UnsafeServiceCServer ¶

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 UnsafeServiceCServer interface {
    // contains filtered or unexported methods
}

type UnsafeSnakeEnumServiceServer ¶

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 UnsafeSnakeEnumServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeStreamServiceServer ¶

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 UnsafeStreamServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeUnannotatedEchoServiceServer ¶

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 UnsafeUnannotatedEchoServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeVisibilityRuleEchoServiceServer ¶

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 UnsafeVisibilityRuleEchoServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeVisibilityRuleInternalEchoServiceServer ¶

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 UnsafeVisibilityRuleInternalEchoServiceServer interface {
    // contains filtered or unexported methods
}

type UnsafeWrappersServiceServer ¶

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 UnsafeWrappersServiceServer interface {
    // contains filtered or unexported methods
}

type UpdateBookRequest ¶

A standard Update message from AIP-134

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

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
}

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 ¶

UpdateV2Request request for update includes the message and the update mask

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
}

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 ¶

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.

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

func NewVisibilityRuleEchoServiceClient ¶

func NewVisibilityRuleEchoServiceClient(cc grpc.ClientConnInterface) VisibilityRuleEchoServiceClient

type VisibilityRuleEchoServiceServer ¶

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

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

type VisibilityRuleEmbedded ¶

Embedded represents a message embedded in SimpleMessage.

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
}

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 ¶

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".

type VisibilityRuleEnumInPreviewMethod int32

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 ¶

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.

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

func NewVisibilityRuleInternalEchoServiceClient ¶

func NewVisibilityRuleInternalEchoServiceClient(cc grpc.ClientConnInterface) VisibilityRuleInternalEchoServiceClient

type VisibilityRuleInternalEchoServiceServer ¶

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

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

type VisibilityRuleMessageInPreviewMethod ¶

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".

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
}

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 ¶

SimpleMessage represents a simple message sent to the Echo service.

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"`
    // contains filtered or unexported fields
}

func (*VisibilityRuleSimpleMessage) Descriptor ¶

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

Deprecated: Use VisibilityRuleSimpleMessage.ProtoReflect.Descriptor instead.

func (*VisibilityRuleSimpleMessage) GetAnEnum ¶

func (x *VisibilityRuleSimpleMessage) GetAnEnum() VisibilityRuleSimpleMessage_VisibilityEnum

func (*VisibilityRuleSimpleMessage) GetCode ¶

func (m *VisibilityRuleSimpleMessage) GetCode() isVisibilityRuleSimpleMessage_Code

func (*VisibilityRuleSimpleMessage) GetEn ¶

func (x *VisibilityRuleSimpleMessage) GetEn() int64

func (*VisibilityRuleSimpleMessage) GetExt ¶

func (m *VisibilityRuleSimpleMessage) GetExt() isVisibilityRuleSimpleMessage_Ext

func (*VisibilityRuleSimpleMessage) GetId ¶

func (x *VisibilityRuleSimpleMessage) GetId() string

func (*VisibilityRuleSimpleMessage) GetInternalField ¶

func (x *VisibilityRuleSimpleMessage) GetInternalField() string

func (*VisibilityRuleSimpleMessage) GetLang ¶

func (x *VisibilityRuleSimpleMessage) GetLang() string

func (*VisibilityRuleSimpleMessage) GetLineNum ¶

func (x *VisibilityRuleSimpleMessage) GetLineNum() int64

func (*VisibilityRuleSimpleMessage) GetNo ¶

func (x *VisibilityRuleSimpleMessage) GetNo() *VisibilityRuleEmbedded

func (*VisibilityRuleSimpleMessage) GetNum ¶

func (x *VisibilityRuleSimpleMessage) GetNum() int64

func (*VisibilityRuleSimpleMessage) GetPreviewField ¶

func (x *VisibilityRuleSimpleMessage) GetPreviewField() string

func (*VisibilityRuleSimpleMessage) GetStatus ¶

func (x *VisibilityRuleSimpleMessage) GetStatus() *VisibilityRuleEmbedded

func (*VisibilityRuleSimpleMessage) ProtoMessage ¶

func (*VisibilityRuleSimpleMessage) ProtoMessage()

func (*VisibilityRuleSimpleMessage) ProtoReflect ¶

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

func (*VisibilityRuleSimpleMessage) Reset ¶

func (x *VisibilityRuleSimpleMessage) Reset()

func (*VisibilityRuleSimpleMessage) String ¶

func (x *VisibilityRuleSimpleMessage) String() string

type VisibilityRuleSimpleMessage_En ¶

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

type VisibilityRuleSimpleMessage_Lang ¶

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

type VisibilityRuleSimpleMessage_LineNum ¶

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

type VisibilityRuleSimpleMessage_No ¶

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

type VisibilityRuleSimpleMessage_VisibilityEnum ¶

type VisibilityRuleSimpleMessage_VisibilityEnum int32

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

func (VisibilityRuleSimpleMessage_VisibilityEnum) Descriptor ¶

func (VisibilityRuleSimpleMessage_VisibilityEnum) Descriptor() protoreflect.EnumDescriptor

func (VisibilityRuleSimpleMessage_VisibilityEnum) Enum ¶

func (x VisibilityRuleSimpleMessage_VisibilityEnum) Enum() *VisibilityRuleSimpleMessage_VisibilityEnum

func (VisibilityRuleSimpleMessage_VisibilityEnum) EnumDescriptor ¶

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

Deprecated: Use VisibilityRuleSimpleMessage_VisibilityEnum.Descriptor instead.

func (VisibilityRuleSimpleMessage_VisibilityEnum) Number ¶

func (x VisibilityRuleSimpleMessage_VisibilityEnum) Number() protoreflect.EnumNumber

func (VisibilityRuleSimpleMessage_VisibilityEnum) String ¶

func (x VisibilityRuleSimpleMessage_VisibilityEnum) String() string

func (VisibilityRuleSimpleMessage_VisibilityEnum) Type ¶

func (VisibilityRuleSimpleMessage_VisibilityEnum) Type() protoreflect.EnumType

type VisibilityRuleSubMessageInPreviewMethod ¶

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".

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

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 ¶

WrappersServiceClient is the client API for WrappersService service.

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

type 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)
}

func NewWrappersServiceClient ¶

func NewWrappersServiceClient(cc grpc.ClientConnInterface) WrappersServiceClient

type WrappersServiceServer ¶

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

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