github.com/Finschia/finschia-sdk@v0.48.1/x/staking/types/query.pb.gw.go (about)

     1  // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
     2  // source: cosmos/staking/v1beta1/query.proto
     3  
     4  /*
     5  Package types is a reverse proxy.
     6  
     7  It translates gRPC into RESTful JSON APIs.
     8  */
     9  package types
    10  
    11  import (
    12  	"context"
    13  	"io"
    14  	"net/http"
    15  
    16  	"github.com/golang/protobuf/descriptor"
    17  	"github.com/golang/protobuf/proto"
    18  	"github.com/grpc-ecosystem/grpc-gateway/runtime"
    19  	"github.com/grpc-ecosystem/grpc-gateway/utilities"
    20  	"google.golang.org/grpc"
    21  	"google.golang.org/grpc/codes"
    22  	"google.golang.org/grpc/grpclog"
    23  	"google.golang.org/grpc/status"
    24  )
    25  
    26  // Suppress "imported and not used" errors
    27  var _ codes.Code
    28  var _ io.Reader
    29  var _ status.Status
    30  var _ = runtime.String
    31  var _ = utilities.NewDoubleArray
    32  var _ = descriptor.ForMessage
    33  
    34  var (
    35  	filter_Query_Validators_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
    36  )
    37  
    38  func request_Query_Validators_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    39  	var protoReq QueryValidatorsRequest
    40  	var metadata runtime.ServerMetadata
    41  
    42  	if err := req.ParseForm(); err != nil {
    43  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    44  	}
    45  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Validators_0); err != nil {
    46  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    47  	}
    48  
    49  	msg, err := client.Validators(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    50  	return msg, metadata, err
    51  
    52  }
    53  
    54  func local_request_Query_Validators_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    55  	var protoReq QueryValidatorsRequest
    56  	var metadata runtime.ServerMetadata
    57  
    58  	if err := req.ParseForm(); err != nil {
    59  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    60  	}
    61  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Validators_0); err != nil {
    62  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    63  	}
    64  
    65  	msg, err := server.Validators(ctx, &protoReq)
    66  	return msg, metadata, err
    67  
    68  }
    69  
    70  func request_Query_Validator_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    71  	var protoReq QueryValidatorRequest
    72  	var metadata runtime.ServerMetadata
    73  
    74  	var (
    75  		val string
    76  		ok  bool
    77  		err error
    78  		_   = err
    79  	)
    80  
    81  	val, ok = pathParams["validator_addr"]
    82  	if !ok {
    83  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
    84  	}
    85  
    86  	protoReq.ValidatorAddr, err = runtime.String(val)
    87  
    88  	if err != nil {
    89  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
    90  	}
    91  
    92  	msg, err := client.Validator(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    93  	return msg, metadata, err
    94  
    95  }
    96  
    97  func local_request_Query_Validator_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    98  	var protoReq QueryValidatorRequest
    99  	var metadata runtime.ServerMetadata
   100  
   101  	var (
   102  		val string
   103  		ok  bool
   104  		err error
   105  		_   = err
   106  	)
   107  
   108  	val, ok = pathParams["validator_addr"]
   109  	if !ok {
   110  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   111  	}
   112  
   113  	protoReq.ValidatorAddr, err = runtime.String(val)
   114  
   115  	if err != nil {
   116  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   117  	}
   118  
   119  	msg, err := server.Validator(ctx, &protoReq)
   120  	return msg, metadata, err
   121  
   122  }
   123  
   124  var (
   125  	filter_Query_ValidatorDelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"validator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   126  )
   127  
   128  func request_Query_ValidatorDelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   129  	var protoReq QueryValidatorDelegationsRequest
   130  	var metadata runtime.ServerMetadata
   131  
   132  	var (
   133  		val string
   134  		ok  bool
   135  		err error
   136  		_   = err
   137  	)
   138  
   139  	val, ok = pathParams["validator_addr"]
   140  	if !ok {
   141  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   142  	}
   143  
   144  	protoReq.ValidatorAddr, err = runtime.String(val)
   145  
   146  	if err != nil {
   147  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   148  	}
   149  
   150  	if err := req.ParseForm(); err != nil {
   151  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   152  	}
   153  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ValidatorDelegations_0); err != nil {
   154  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   155  	}
   156  
   157  	msg, err := client.ValidatorDelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   158  	return msg, metadata, err
   159  
   160  }
   161  
   162  func local_request_Query_ValidatorDelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   163  	var protoReq QueryValidatorDelegationsRequest
   164  	var metadata runtime.ServerMetadata
   165  
   166  	var (
   167  		val string
   168  		ok  bool
   169  		err error
   170  		_   = err
   171  	)
   172  
   173  	val, ok = pathParams["validator_addr"]
   174  	if !ok {
   175  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   176  	}
   177  
   178  	protoReq.ValidatorAddr, err = runtime.String(val)
   179  
   180  	if err != nil {
   181  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   182  	}
   183  
   184  	if err := req.ParseForm(); err != nil {
   185  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   186  	}
   187  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ValidatorDelegations_0); err != nil {
   188  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   189  	}
   190  
   191  	msg, err := server.ValidatorDelegations(ctx, &protoReq)
   192  	return msg, metadata, err
   193  
   194  }
   195  
   196  var (
   197  	filter_Query_ValidatorUnbondingDelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"validator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   198  )
   199  
   200  func request_Query_ValidatorUnbondingDelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   201  	var protoReq QueryValidatorUnbondingDelegationsRequest
   202  	var metadata runtime.ServerMetadata
   203  
   204  	var (
   205  		val string
   206  		ok  bool
   207  		err error
   208  		_   = err
   209  	)
   210  
   211  	val, ok = pathParams["validator_addr"]
   212  	if !ok {
   213  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   214  	}
   215  
   216  	protoReq.ValidatorAddr, err = runtime.String(val)
   217  
   218  	if err != nil {
   219  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   220  	}
   221  
   222  	if err := req.ParseForm(); err != nil {
   223  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   224  	}
   225  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ValidatorUnbondingDelegations_0); err != nil {
   226  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   227  	}
   228  
   229  	msg, err := client.ValidatorUnbondingDelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   230  	return msg, metadata, err
   231  
   232  }
   233  
   234  func local_request_Query_ValidatorUnbondingDelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   235  	var protoReq QueryValidatorUnbondingDelegationsRequest
   236  	var metadata runtime.ServerMetadata
   237  
   238  	var (
   239  		val string
   240  		ok  bool
   241  		err error
   242  		_   = err
   243  	)
   244  
   245  	val, ok = pathParams["validator_addr"]
   246  	if !ok {
   247  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   248  	}
   249  
   250  	protoReq.ValidatorAddr, err = runtime.String(val)
   251  
   252  	if err != nil {
   253  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   254  	}
   255  
   256  	if err := req.ParseForm(); err != nil {
   257  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   258  	}
   259  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ValidatorUnbondingDelegations_0); err != nil {
   260  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   261  	}
   262  
   263  	msg, err := server.ValidatorUnbondingDelegations(ctx, &protoReq)
   264  	return msg, metadata, err
   265  
   266  }
   267  
   268  func request_Query_Delegation_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   269  	var protoReq QueryDelegationRequest
   270  	var metadata runtime.ServerMetadata
   271  
   272  	var (
   273  		val string
   274  		ok  bool
   275  		err error
   276  		_   = err
   277  	)
   278  
   279  	val, ok = pathParams["validator_addr"]
   280  	if !ok {
   281  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   282  	}
   283  
   284  	protoReq.ValidatorAddr, err = runtime.String(val)
   285  
   286  	if err != nil {
   287  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   288  	}
   289  
   290  	val, ok = pathParams["delegator_addr"]
   291  	if !ok {
   292  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   293  	}
   294  
   295  	protoReq.DelegatorAddr, err = runtime.String(val)
   296  
   297  	if err != nil {
   298  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   299  	}
   300  
   301  	msg, err := client.Delegation(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   302  	return msg, metadata, err
   303  
   304  }
   305  
   306  func local_request_Query_Delegation_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   307  	var protoReq QueryDelegationRequest
   308  	var metadata runtime.ServerMetadata
   309  
   310  	var (
   311  		val string
   312  		ok  bool
   313  		err error
   314  		_   = err
   315  	)
   316  
   317  	val, ok = pathParams["validator_addr"]
   318  	if !ok {
   319  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   320  	}
   321  
   322  	protoReq.ValidatorAddr, err = runtime.String(val)
   323  
   324  	if err != nil {
   325  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   326  	}
   327  
   328  	val, ok = pathParams["delegator_addr"]
   329  	if !ok {
   330  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   331  	}
   332  
   333  	protoReq.DelegatorAddr, err = runtime.String(val)
   334  
   335  	if err != nil {
   336  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   337  	}
   338  
   339  	msg, err := server.Delegation(ctx, &protoReq)
   340  	return msg, metadata, err
   341  
   342  }
   343  
   344  func request_Query_UnbondingDelegation_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   345  	var protoReq QueryUnbondingDelegationRequest
   346  	var metadata runtime.ServerMetadata
   347  
   348  	var (
   349  		val string
   350  		ok  bool
   351  		err error
   352  		_   = err
   353  	)
   354  
   355  	val, ok = pathParams["validator_addr"]
   356  	if !ok {
   357  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   358  	}
   359  
   360  	protoReq.ValidatorAddr, err = runtime.String(val)
   361  
   362  	if err != nil {
   363  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   364  	}
   365  
   366  	val, ok = pathParams["delegator_addr"]
   367  	if !ok {
   368  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   369  	}
   370  
   371  	protoReq.DelegatorAddr, err = runtime.String(val)
   372  
   373  	if err != nil {
   374  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   375  	}
   376  
   377  	msg, err := client.UnbondingDelegation(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   378  	return msg, metadata, err
   379  
   380  }
   381  
   382  func local_request_Query_UnbondingDelegation_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   383  	var protoReq QueryUnbondingDelegationRequest
   384  	var metadata runtime.ServerMetadata
   385  
   386  	var (
   387  		val string
   388  		ok  bool
   389  		err error
   390  		_   = err
   391  	)
   392  
   393  	val, ok = pathParams["validator_addr"]
   394  	if !ok {
   395  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   396  	}
   397  
   398  	protoReq.ValidatorAddr, err = runtime.String(val)
   399  
   400  	if err != nil {
   401  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   402  	}
   403  
   404  	val, ok = pathParams["delegator_addr"]
   405  	if !ok {
   406  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   407  	}
   408  
   409  	protoReq.DelegatorAddr, err = runtime.String(val)
   410  
   411  	if err != nil {
   412  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   413  	}
   414  
   415  	msg, err := server.UnbondingDelegation(ctx, &protoReq)
   416  	return msg, metadata, err
   417  
   418  }
   419  
   420  var (
   421  	filter_Query_DelegatorDelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"delegator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   422  )
   423  
   424  func request_Query_DelegatorDelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   425  	var protoReq QueryDelegatorDelegationsRequest
   426  	var metadata runtime.ServerMetadata
   427  
   428  	var (
   429  		val string
   430  		ok  bool
   431  		err error
   432  		_   = err
   433  	)
   434  
   435  	val, ok = pathParams["delegator_addr"]
   436  	if !ok {
   437  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   438  	}
   439  
   440  	protoReq.DelegatorAddr, err = runtime.String(val)
   441  
   442  	if err != nil {
   443  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   444  	}
   445  
   446  	if err := req.ParseForm(); err != nil {
   447  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   448  	}
   449  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorDelegations_0); err != nil {
   450  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   451  	}
   452  
   453  	msg, err := client.DelegatorDelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   454  	return msg, metadata, err
   455  
   456  }
   457  
   458  func local_request_Query_DelegatorDelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   459  	var protoReq QueryDelegatorDelegationsRequest
   460  	var metadata runtime.ServerMetadata
   461  
   462  	var (
   463  		val string
   464  		ok  bool
   465  		err error
   466  		_   = err
   467  	)
   468  
   469  	val, ok = pathParams["delegator_addr"]
   470  	if !ok {
   471  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   472  	}
   473  
   474  	protoReq.DelegatorAddr, err = runtime.String(val)
   475  
   476  	if err != nil {
   477  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   478  	}
   479  
   480  	if err := req.ParseForm(); err != nil {
   481  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   482  	}
   483  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorDelegations_0); err != nil {
   484  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   485  	}
   486  
   487  	msg, err := server.DelegatorDelegations(ctx, &protoReq)
   488  	return msg, metadata, err
   489  
   490  }
   491  
   492  var (
   493  	filter_Query_DelegatorUnbondingDelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"delegator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   494  )
   495  
   496  func request_Query_DelegatorUnbondingDelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   497  	var protoReq QueryDelegatorUnbondingDelegationsRequest
   498  	var metadata runtime.ServerMetadata
   499  
   500  	var (
   501  		val string
   502  		ok  bool
   503  		err error
   504  		_   = err
   505  	)
   506  
   507  	val, ok = pathParams["delegator_addr"]
   508  	if !ok {
   509  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   510  	}
   511  
   512  	protoReq.DelegatorAddr, err = runtime.String(val)
   513  
   514  	if err != nil {
   515  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   516  	}
   517  
   518  	if err := req.ParseForm(); err != nil {
   519  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   520  	}
   521  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorUnbondingDelegations_0); err != nil {
   522  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   523  	}
   524  
   525  	msg, err := client.DelegatorUnbondingDelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   526  	return msg, metadata, err
   527  
   528  }
   529  
   530  func local_request_Query_DelegatorUnbondingDelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   531  	var protoReq QueryDelegatorUnbondingDelegationsRequest
   532  	var metadata runtime.ServerMetadata
   533  
   534  	var (
   535  		val string
   536  		ok  bool
   537  		err error
   538  		_   = err
   539  	)
   540  
   541  	val, ok = pathParams["delegator_addr"]
   542  	if !ok {
   543  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   544  	}
   545  
   546  	protoReq.DelegatorAddr, err = runtime.String(val)
   547  
   548  	if err != nil {
   549  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   550  	}
   551  
   552  	if err := req.ParseForm(); err != nil {
   553  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   554  	}
   555  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorUnbondingDelegations_0); err != nil {
   556  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   557  	}
   558  
   559  	msg, err := server.DelegatorUnbondingDelegations(ctx, &protoReq)
   560  	return msg, metadata, err
   561  
   562  }
   563  
   564  var (
   565  	filter_Query_Redelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"delegator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   566  )
   567  
   568  func request_Query_Redelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   569  	var protoReq QueryRedelegationsRequest
   570  	var metadata runtime.ServerMetadata
   571  
   572  	var (
   573  		val string
   574  		ok  bool
   575  		err error
   576  		_   = err
   577  	)
   578  
   579  	val, ok = pathParams["delegator_addr"]
   580  	if !ok {
   581  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   582  	}
   583  
   584  	protoReq.DelegatorAddr, err = runtime.String(val)
   585  
   586  	if err != nil {
   587  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   588  	}
   589  
   590  	if err := req.ParseForm(); err != nil {
   591  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   592  	}
   593  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Redelegations_0); err != nil {
   594  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   595  	}
   596  
   597  	msg, err := client.Redelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   598  	return msg, metadata, err
   599  
   600  }
   601  
   602  func local_request_Query_Redelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   603  	var protoReq QueryRedelegationsRequest
   604  	var metadata runtime.ServerMetadata
   605  
   606  	var (
   607  		val string
   608  		ok  bool
   609  		err error
   610  		_   = err
   611  	)
   612  
   613  	val, ok = pathParams["delegator_addr"]
   614  	if !ok {
   615  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   616  	}
   617  
   618  	protoReq.DelegatorAddr, err = runtime.String(val)
   619  
   620  	if err != nil {
   621  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   622  	}
   623  
   624  	if err := req.ParseForm(); err != nil {
   625  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   626  	}
   627  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Redelegations_0); err != nil {
   628  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   629  	}
   630  
   631  	msg, err := server.Redelegations(ctx, &protoReq)
   632  	return msg, metadata, err
   633  
   634  }
   635  
   636  var (
   637  	filter_Query_DelegatorValidators_0 = &utilities.DoubleArray{Encoding: map[string]int{"delegator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
   638  )
   639  
   640  func request_Query_DelegatorValidators_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   641  	var protoReq QueryDelegatorValidatorsRequest
   642  	var metadata runtime.ServerMetadata
   643  
   644  	var (
   645  		val string
   646  		ok  bool
   647  		err error
   648  		_   = err
   649  	)
   650  
   651  	val, ok = pathParams["delegator_addr"]
   652  	if !ok {
   653  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   654  	}
   655  
   656  	protoReq.DelegatorAddr, err = runtime.String(val)
   657  
   658  	if err != nil {
   659  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   660  	}
   661  
   662  	if err := req.ParseForm(); err != nil {
   663  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   664  	}
   665  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorValidators_0); err != nil {
   666  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   667  	}
   668  
   669  	msg, err := client.DelegatorValidators(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   670  	return msg, metadata, err
   671  
   672  }
   673  
   674  func local_request_Query_DelegatorValidators_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   675  	var protoReq QueryDelegatorValidatorsRequest
   676  	var metadata runtime.ServerMetadata
   677  
   678  	var (
   679  		val string
   680  		ok  bool
   681  		err error
   682  		_   = err
   683  	)
   684  
   685  	val, ok = pathParams["delegator_addr"]
   686  	if !ok {
   687  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   688  	}
   689  
   690  	protoReq.DelegatorAddr, err = runtime.String(val)
   691  
   692  	if err != nil {
   693  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   694  	}
   695  
   696  	if err := req.ParseForm(); err != nil {
   697  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   698  	}
   699  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorValidators_0); err != nil {
   700  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   701  	}
   702  
   703  	msg, err := server.DelegatorValidators(ctx, &protoReq)
   704  	return msg, metadata, err
   705  
   706  }
   707  
   708  func request_Query_DelegatorValidator_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   709  	var protoReq QueryDelegatorValidatorRequest
   710  	var metadata runtime.ServerMetadata
   711  
   712  	var (
   713  		val string
   714  		ok  bool
   715  		err error
   716  		_   = err
   717  	)
   718  
   719  	val, ok = pathParams["delegator_addr"]
   720  	if !ok {
   721  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   722  	}
   723  
   724  	protoReq.DelegatorAddr, err = runtime.String(val)
   725  
   726  	if err != nil {
   727  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   728  	}
   729  
   730  	val, ok = pathParams["validator_addr"]
   731  	if !ok {
   732  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   733  	}
   734  
   735  	protoReq.ValidatorAddr, err = runtime.String(val)
   736  
   737  	if err != nil {
   738  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   739  	}
   740  
   741  	msg, err := client.DelegatorValidator(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   742  	return msg, metadata, err
   743  
   744  }
   745  
   746  func local_request_Query_DelegatorValidator_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   747  	var protoReq QueryDelegatorValidatorRequest
   748  	var metadata runtime.ServerMetadata
   749  
   750  	var (
   751  		val string
   752  		ok  bool
   753  		err error
   754  		_   = err
   755  	)
   756  
   757  	val, ok = pathParams["delegator_addr"]
   758  	if !ok {
   759  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr")
   760  	}
   761  
   762  	protoReq.DelegatorAddr, err = runtime.String(val)
   763  
   764  	if err != nil {
   765  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err)
   766  	}
   767  
   768  	val, ok = pathParams["validator_addr"]
   769  	if !ok {
   770  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr")
   771  	}
   772  
   773  	protoReq.ValidatorAddr, err = runtime.String(val)
   774  
   775  	if err != nil {
   776  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err)
   777  	}
   778  
   779  	msg, err := server.DelegatorValidator(ctx, &protoReq)
   780  	return msg, metadata, err
   781  
   782  }
   783  
   784  func request_Query_HistoricalInfo_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   785  	var protoReq QueryHistoricalInfoRequest
   786  	var metadata runtime.ServerMetadata
   787  
   788  	var (
   789  		val string
   790  		ok  bool
   791  		err error
   792  		_   = err
   793  	)
   794  
   795  	val, ok = pathParams["height"]
   796  	if !ok {
   797  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height")
   798  	}
   799  
   800  	protoReq.Height, err = runtime.Int64(val)
   801  
   802  	if err != nil {
   803  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err)
   804  	}
   805  
   806  	msg, err := client.HistoricalInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   807  	return msg, metadata, err
   808  
   809  }
   810  
   811  func local_request_Query_HistoricalInfo_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   812  	var protoReq QueryHistoricalInfoRequest
   813  	var metadata runtime.ServerMetadata
   814  
   815  	var (
   816  		val string
   817  		ok  bool
   818  		err error
   819  		_   = err
   820  	)
   821  
   822  	val, ok = pathParams["height"]
   823  	if !ok {
   824  		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height")
   825  	}
   826  
   827  	protoReq.Height, err = runtime.Int64(val)
   828  
   829  	if err != nil {
   830  		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err)
   831  	}
   832  
   833  	msg, err := server.HistoricalInfo(ctx, &protoReq)
   834  	return msg, metadata, err
   835  
   836  }
   837  
   838  func request_Query_Pool_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   839  	var protoReq QueryPoolRequest
   840  	var metadata runtime.ServerMetadata
   841  
   842  	msg, err := client.Pool(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   843  	return msg, metadata, err
   844  
   845  }
   846  
   847  func local_request_Query_Pool_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   848  	var protoReq QueryPoolRequest
   849  	var metadata runtime.ServerMetadata
   850  
   851  	msg, err := server.Pool(ctx, &protoReq)
   852  	return msg, metadata, err
   853  
   854  }
   855  
   856  func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   857  	var protoReq QueryParamsRequest
   858  	var metadata runtime.ServerMetadata
   859  
   860  	msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   861  	return msg, metadata, err
   862  
   863  }
   864  
   865  func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   866  	var protoReq QueryParamsRequest
   867  	var metadata runtime.ServerMetadata
   868  
   869  	msg, err := server.Params(ctx, &protoReq)
   870  	return msg, metadata, err
   871  
   872  }
   873  
   874  // RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
   875  // UnaryRPC     :call QueryServer directly.
   876  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
   877  // Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.
   878  func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error {
   879  
   880  	mux.Handle("GET", pattern_Query_Validators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   881  		ctx, cancel := context.WithCancel(req.Context())
   882  		defer cancel()
   883  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   884  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   885  		if err != nil {
   886  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   887  			return
   888  		}
   889  		resp, md, err := local_request_Query_Validators_0(rctx, inboundMarshaler, server, req, pathParams)
   890  		ctx = runtime.NewServerMetadataContext(ctx, md)
   891  		if err != nil {
   892  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   893  			return
   894  		}
   895  
   896  		forward_Query_Validators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   897  
   898  	})
   899  
   900  	mux.Handle("GET", pattern_Query_Validator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   901  		ctx, cancel := context.WithCancel(req.Context())
   902  		defer cancel()
   903  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   904  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   905  		if err != nil {
   906  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   907  			return
   908  		}
   909  		resp, md, err := local_request_Query_Validator_0(rctx, inboundMarshaler, server, req, pathParams)
   910  		ctx = runtime.NewServerMetadataContext(ctx, md)
   911  		if err != nil {
   912  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   913  			return
   914  		}
   915  
   916  		forward_Query_Validator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   917  
   918  	})
   919  
   920  	mux.Handle("GET", pattern_Query_ValidatorDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   921  		ctx, cancel := context.WithCancel(req.Context())
   922  		defer cancel()
   923  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   924  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   925  		if err != nil {
   926  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   927  			return
   928  		}
   929  		resp, md, err := local_request_Query_ValidatorDelegations_0(rctx, inboundMarshaler, server, req, pathParams)
   930  		ctx = runtime.NewServerMetadataContext(ctx, md)
   931  		if err != nil {
   932  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   933  			return
   934  		}
   935  
   936  		forward_Query_ValidatorDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   937  
   938  	})
   939  
   940  	mux.Handle("GET", pattern_Query_ValidatorUnbondingDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   941  		ctx, cancel := context.WithCancel(req.Context())
   942  		defer cancel()
   943  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   944  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   945  		if err != nil {
   946  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   947  			return
   948  		}
   949  		resp, md, err := local_request_Query_ValidatorUnbondingDelegations_0(rctx, inboundMarshaler, server, req, pathParams)
   950  		ctx = runtime.NewServerMetadataContext(ctx, md)
   951  		if err != nil {
   952  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   953  			return
   954  		}
   955  
   956  		forward_Query_ValidatorUnbondingDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   957  
   958  	})
   959  
   960  	mux.Handle("GET", pattern_Query_Delegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   961  		ctx, cancel := context.WithCancel(req.Context())
   962  		defer cancel()
   963  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   964  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   965  		if err != nil {
   966  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   967  			return
   968  		}
   969  		resp, md, err := local_request_Query_Delegation_0(rctx, inboundMarshaler, server, req, pathParams)
   970  		ctx = runtime.NewServerMetadataContext(ctx, md)
   971  		if err != nil {
   972  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   973  			return
   974  		}
   975  
   976  		forward_Query_Delegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   977  
   978  	})
   979  
   980  	mux.Handle("GET", pattern_Query_UnbondingDelegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   981  		ctx, cancel := context.WithCancel(req.Context())
   982  		defer cancel()
   983  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   984  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   985  		if err != nil {
   986  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   987  			return
   988  		}
   989  		resp, md, err := local_request_Query_UnbondingDelegation_0(rctx, inboundMarshaler, server, req, pathParams)
   990  		ctx = runtime.NewServerMetadataContext(ctx, md)
   991  		if err != nil {
   992  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   993  			return
   994  		}
   995  
   996  		forward_Query_UnbondingDelegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   997  
   998  	})
   999  
  1000  	mux.Handle("GET", pattern_Query_DelegatorDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1001  		ctx, cancel := context.WithCancel(req.Context())
  1002  		defer cancel()
  1003  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1004  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1005  		if err != nil {
  1006  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1007  			return
  1008  		}
  1009  		resp, md, err := local_request_Query_DelegatorDelegations_0(rctx, inboundMarshaler, server, req, pathParams)
  1010  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1011  		if err != nil {
  1012  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1013  			return
  1014  		}
  1015  
  1016  		forward_Query_DelegatorDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1017  
  1018  	})
  1019  
  1020  	mux.Handle("GET", pattern_Query_DelegatorUnbondingDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1021  		ctx, cancel := context.WithCancel(req.Context())
  1022  		defer cancel()
  1023  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1024  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1025  		if err != nil {
  1026  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1027  			return
  1028  		}
  1029  		resp, md, err := local_request_Query_DelegatorUnbondingDelegations_0(rctx, inboundMarshaler, server, req, pathParams)
  1030  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1031  		if err != nil {
  1032  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1033  			return
  1034  		}
  1035  
  1036  		forward_Query_DelegatorUnbondingDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1037  
  1038  	})
  1039  
  1040  	mux.Handle("GET", pattern_Query_Redelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1041  		ctx, cancel := context.WithCancel(req.Context())
  1042  		defer cancel()
  1043  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1044  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1045  		if err != nil {
  1046  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1047  			return
  1048  		}
  1049  		resp, md, err := local_request_Query_Redelegations_0(rctx, inboundMarshaler, server, req, pathParams)
  1050  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1051  		if err != nil {
  1052  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1053  			return
  1054  		}
  1055  
  1056  		forward_Query_Redelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1057  
  1058  	})
  1059  
  1060  	mux.Handle("GET", pattern_Query_DelegatorValidators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1061  		ctx, cancel := context.WithCancel(req.Context())
  1062  		defer cancel()
  1063  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1064  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1065  		if err != nil {
  1066  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1067  			return
  1068  		}
  1069  		resp, md, err := local_request_Query_DelegatorValidators_0(rctx, inboundMarshaler, server, req, pathParams)
  1070  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1071  		if err != nil {
  1072  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1073  			return
  1074  		}
  1075  
  1076  		forward_Query_DelegatorValidators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1077  
  1078  	})
  1079  
  1080  	mux.Handle("GET", pattern_Query_DelegatorValidator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1081  		ctx, cancel := context.WithCancel(req.Context())
  1082  		defer cancel()
  1083  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1084  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1085  		if err != nil {
  1086  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1087  			return
  1088  		}
  1089  		resp, md, err := local_request_Query_DelegatorValidator_0(rctx, inboundMarshaler, server, req, pathParams)
  1090  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1091  		if err != nil {
  1092  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1093  			return
  1094  		}
  1095  
  1096  		forward_Query_DelegatorValidator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1097  
  1098  	})
  1099  
  1100  	mux.Handle("GET", pattern_Query_HistoricalInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1101  		ctx, cancel := context.WithCancel(req.Context())
  1102  		defer cancel()
  1103  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1104  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1105  		if err != nil {
  1106  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1107  			return
  1108  		}
  1109  		resp, md, err := local_request_Query_HistoricalInfo_0(rctx, inboundMarshaler, server, req, pathParams)
  1110  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1111  		if err != nil {
  1112  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1113  			return
  1114  		}
  1115  
  1116  		forward_Query_HistoricalInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1117  
  1118  	})
  1119  
  1120  	mux.Handle("GET", pattern_Query_Pool_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1121  		ctx, cancel := context.WithCancel(req.Context())
  1122  		defer cancel()
  1123  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1124  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1125  		if err != nil {
  1126  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1127  			return
  1128  		}
  1129  		resp, md, err := local_request_Query_Pool_0(rctx, inboundMarshaler, server, req, pathParams)
  1130  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1131  		if err != nil {
  1132  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1133  			return
  1134  		}
  1135  
  1136  		forward_Query_Pool_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1137  
  1138  	})
  1139  
  1140  	mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1141  		ctx, cancel := context.WithCancel(req.Context())
  1142  		defer cancel()
  1143  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1144  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1145  		if err != nil {
  1146  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1147  			return
  1148  		}
  1149  		resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams)
  1150  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1151  		if err != nil {
  1152  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1153  			return
  1154  		}
  1155  
  1156  		forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1157  
  1158  	})
  1159  
  1160  	return nil
  1161  }
  1162  
  1163  // RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but
  1164  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  1165  func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  1166  	conn, err := grpc.Dial(endpoint, opts...)
  1167  	if err != nil {
  1168  		return err
  1169  	}
  1170  	defer func() {
  1171  		if err != nil {
  1172  			if cerr := conn.Close(); cerr != nil {
  1173  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  1174  			}
  1175  			return
  1176  		}
  1177  		go func() {
  1178  			<-ctx.Done()
  1179  			if cerr := conn.Close(); cerr != nil {
  1180  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  1181  			}
  1182  		}()
  1183  	}()
  1184  
  1185  	return RegisterQueryHandler(ctx, mux, conn)
  1186  }
  1187  
  1188  // RegisterQueryHandler registers the http handlers for service Query to "mux".
  1189  // The handlers forward requests to the grpc endpoint over "conn".
  1190  func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  1191  	return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn))
  1192  }
  1193  
  1194  // RegisterQueryHandlerClient registers the http handlers for service Query
  1195  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient".
  1196  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient"
  1197  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  1198  // "QueryClient" to call the correct interceptors.
  1199  func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error {
  1200  
  1201  	mux.Handle("GET", pattern_Query_Validators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1202  		ctx, cancel := context.WithCancel(req.Context())
  1203  		defer cancel()
  1204  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1205  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1206  		if err != nil {
  1207  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1208  			return
  1209  		}
  1210  		resp, md, err := request_Query_Validators_0(rctx, inboundMarshaler, client, req, pathParams)
  1211  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1212  		if err != nil {
  1213  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1214  			return
  1215  		}
  1216  
  1217  		forward_Query_Validators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1218  
  1219  	})
  1220  
  1221  	mux.Handle("GET", pattern_Query_Validator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1222  		ctx, cancel := context.WithCancel(req.Context())
  1223  		defer cancel()
  1224  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1225  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1226  		if err != nil {
  1227  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1228  			return
  1229  		}
  1230  		resp, md, err := request_Query_Validator_0(rctx, inboundMarshaler, client, req, pathParams)
  1231  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1232  		if err != nil {
  1233  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1234  			return
  1235  		}
  1236  
  1237  		forward_Query_Validator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1238  
  1239  	})
  1240  
  1241  	mux.Handle("GET", pattern_Query_ValidatorDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1242  		ctx, cancel := context.WithCancel(req.Context())
  1243  		defer cancel()
  1244  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1245  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1246  		if err != nil {
  1247  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1248  			return
  1249  		}
  1250  		resp, md, err := request_Query_ValidatorDelegations_0(rctx, inboundMarshaler, client, req, pathParams)
  1251  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1252  		if err != nil {
  1253  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1254  			return
  1255  		}
  1256  
  1257  		forward_Query_ValidatorDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1258  
  1259  	})
  1260  
  1261  	mux.Handle("GET", pattern_Query_ValidatorUnbondingDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1262  		ctx, cancel := context.WithCancel(req.Context())
  1263  		defer cancel()
  1264  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1265  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1266  		if err != nil {
  1267  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1268  			return
  1269  		}
  1270  		resp, md, err := request_Query_ValidatorUnbondingDelegations_0(rctx, inboundMarshaler, client, req, pathParams)
  1271  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1272  		if err != nil {
  1273  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1274  			return
  1275  		}
  1276  
  1277  		forward_Query_ValidatorUnbondingDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1278  
  1279  	})
  1280  
  1281  	mux.Handle("GET", pattern_Query_Delegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1282  		ctx, cancel := context.WithCancel(req.Context())
  1283  		defer cancel()
  1284  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1285  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1286  		if err != nil {
  1287  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1288  			return
  1289  		}
  1290  		resp, md, err := request_Query_Delegation_0(rctx, inboundMarshaler, client, req, pathParams)
  1291  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1292  		if err != nil {
  1293  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1294  			return
  1295  		}
  1296  
  1297  		forward_Query_Delegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1298  
  1299  	})
  1300  
  1301  	mux.Handle("GET", pattern_Query_UnbondingDelegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1302  		ctx, cancel := context.WithCancel(req.Context())
  1303  		defer cancel()
  1304  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1305  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1306  		if err != nil {
  1307  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1308  			return
  1309  		}
  1310  		resp, md, err := request_Query_UnbondingDelegation_0(rctx, inboundMarshaler, client, req, pathParams)
  1311  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1312  		if err != nil {
  1313  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1314  			return
  1315  		}
  1316  
  1317  		forward_Query_UnbondingDelegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1318  
  1319  	})
  1320  
  1321  	mux.Handle("GET", pattern_Query_DelegatorDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1322  		ctx, cancel := context.WithCancel(req.Context())
  1323  		defer cancel()
  1324  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1325  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1326  		if err != nil {
  1327  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1328  			return
  1329  		}
  1330  		resp, md, err := request_Query_DelegatorDelegations_0(rctx, inboundMarshaler, client, req, pathParams)
  1331  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1332  		if err != nil {
  1333  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1334  			return
  1335  		}
  1336  
  1337  		forward_Query_DelegatorDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1338  
  1339  	})
  1340  
  1341  	mux.Handle("GET", pattern_Query_DelegatorUnbondingDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1342  		ctx, cancel := context.WithCancel(req.Context())
  1343  		defer cancel()
  1344  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1345  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1346  		if err != nil {
  1347  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1348  			return
  1349  		}
  1350  		resp, md, err := request_Query_DelegatorUnbondingDelegations_0(rctx, inboundMarshaler, client, req, pathParams)
  1351  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1352  		if err != nil {
  1353  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1354  			return
  1355  		}
  1356  
  1357  		forward_Query_DelegatorUnbondingDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1358  
  1359  	})
  1360  
  1361  	mux.Handle("GET", pattern_Query_Redelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1362  		ctx, cancel := context.WithCancel(req.Context())
  1363  		defer cancel()
  1364  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1365  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1366  		if err != nil {
  1367  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1368  			return
  1369  		}
  1370  		resp, md, err := request_Query_Redelegations_0(rctx, inboundMarshaler, client, req, pathParams)
  1371  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1372  		if err != nil {
  1373  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1374  			return
  1375  		}
  1376  
  1377  		forward_Query_Redelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1378  
  1379  	})
  1380  
  1381  	mux.Handle("GET", pattern_Query_DelegatorValidators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1382  		ctx, cancel := context.WithCancel(req.Context())
  1383  		defer cancel()
  1384  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1385  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1386  		if err != nil {
  1387  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1388  			return
  1389  		}
  1390  		resp, md, err := request_Query_DelegatorValidators_0(rctx, inboundMarshaler, client, req, pathParams)
  1391  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1392  		if err != nil {
  1393  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1394  			return
  1395  		}
  1396  
  1397  		forward_Query_DelegatorValidators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1398  
  1399  	})
  1400  
  1401  	mux.Handle("GET", pattern_Query_DelegatorValidator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1402  		ctx, cancel := context.WithCancel(req.Context())
  1403  		defer cancel()
  1404  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1405  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1406  		if err != nil {
  1407  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1408  			return
  1409  		}
  1410  		resp, md, err := request_Query_DelegatorValidator_0(rctx, inboundMarshaler, client, req, pathParams)
  1411  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1412  		if err != nil {
  1413  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1414  			return
  1415  		}
  1416  
  1417  		forward_Query_DelegatorValidator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1418  
  1419  	})
  1420  
  1421  	mux.Handle("GET", pattern_Query_HistoricalInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1422  		ctx, cancel := context.WithCancel(req.Context())
  1423  		defer cancel()
  1424  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1425  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1426  		if err != nil {
  1427  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1428  			return
  1429  		}
  1430  		resp, md, err := request_Query_HistoricalInfo_0(rctx, inboundMarshaler, client, req, pathParams)
  1431  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1432  		if err != nil {
  1433  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1434  			return
  1435  		}
  1436  
  1437  		forward_Query_HistoricalInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1438  
  1439  	})
  1440  
  1441  	mux.Handle("GET", pattern_Query_Pool_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1442  		ctx, cancel := context.WithCancel(req.Context())
  1443  		defer cancel()
  1444  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1445  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1446  		if err != nil {
  1447  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1448  			return
  1449  		}
  1450  		resp, md, err := request_Query_Pool_0(rctx, inboundMarshaler, client, req, pathParams)
  1451  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1452  		if err != nil {
  1453  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1454  			return
  1455  		}
  1456  
  1457  		forward_Query_Pool_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1458  
  1459  	})
  1460  
  1461  	mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1462  		ctx, cancel := context.WithCancel(req.Context())
  1463  		defer cancel()
  1464  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1465  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  1466  		if err != nil {
  1467  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1468  			return
  1469  		}
  1470  		resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams)
  1471  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1472  		if err != nil {
  1473  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1474  			return
  1475  		}
  1476  
  1477  		forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1478  
  1479  	})
  1480  
  1481  	return nil
  1482  }
  1483  
  1484  var (
  1485  	pattern_Query_Validators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "staking", "v1beta1", "validators"}, "", runtime.AssumeColonVerbOpt(false)))
  1486  
  1487  	pattern_Query_Validator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr"}, "", runtime.AssumeColonVerbOpt(false)))
  1488  
  1489  	pattern_Query_ValidatorDelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr", "delegations"}, "", runtime.AssumeColonVerbOpt(false)))
  1490  
  1491  	pattern_Query_ValidatorUnbondingDelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr", "unbonding_delegations"}, "", runtime.AssumeColonVerbOpt(false)))
  1492  
  1493  	pattern_Query_Delegation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr", "delegations", "delegator_addr"}, "", runtime.AssumeColonVerbOpt(false)))
  1494  
  1495  	pattern_Query_UnbondingDelegation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr", "delegations", "delegator_addr", "unbonding_delegation"}, "", runtime.AssumeColonVerbOpt(false)))
  1496  
  1497  	pattern_Query_DelegatorDelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "staking", "v1beta1", "delegations", "delegator_addr"}, "", runtime.AssumeColonVerbOpt(false)))
  1498  
  1499  	pattern_Query_DelegatorUnbondingDelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "delegators", "delegator_addr", "unbonding_delegations"}, "", runtime.AssumeColonVerbOpt(false)))
  1500  
  1501  	pattern_Query_Redelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "delegators", "delegator_addr", "redelegations"}, "", runtime.AssumeColonVerbOpt(false)))
  1502  
  1503  	pattern_Query_DelegatorValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "delegators", "delegator_addr", "validators"}, "", runtime.AssumeColonVerbOpt(false)))
  1504  
  1505  	pattern_Query_DelegatorValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"cosmos", "staking", "v1beta1", "delegators", "delegator_addr", "validators", "validator_addr"}, "", runtime.AssumeColonVerbOpt(false)))
  1506  
  1507  	pattern_Query_HistoricalInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "staking", "v1beta1", "historical_info", "height"}, "", runtime.AssumeColonVerbOpt(false)))
  1508  
  1509  	pattern_Query_Pool_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "staking", "v1beta1", "pool"}, "", runtime.AssumeColonVerbOpt(false)))
  1510  
  1511  	pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "staking", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(false)))
  1512  )
  1513  
  1514  var (
  1515  	forward_Query_Validators_0 = runtime.ForwardResponseMessage
  1516  
  1517  	forward_Query_Validator_0 = runtime.ForwardResponseMessage
  1518  
  1519  	forward_Query_ValidatorDelegations_0 = runtime.ForwardResponseMessage
  1520  
  1521  	forward_Query_ValidatorUnbondingDelegations_0 = runtime.ForwardResponseMessage
  1522  
  1523  	forward_Query_Delegation_0 = runtime.ForwardResponseMessage
  1524  
  1525  	forward_Query_UnbondingDelegation_0 = runtime.ForwardResponseMessage
  1526  
  1527  	forward_Query_DelegatorDelegations_0 = runtime.ForwardResponseMessage
  1528  
  1529  	forward_Query_DelegatorUnbondingDelegations_0 = runtime.ForwardResponseMessage
  1530  
  1531  	forward_Query_Redelegations_0 = runtime.ForwardResponseMessage
  1532  
  1533  	forward_Query_DelegatorValidators_0 = runtime.ForwardResponseMessage
  1534  
  1535  	forward_Query_DelegatorValidator_0 = runtime.ForwardResponseMessage
  1536  
  1537  	forward_Query_HistoricalInfo_0 = runtime.ForwardResponseMessage
  1538  
  1539  	forward_Query_Pool_0 = runtime.ForwardResponseMessage
  1540  
  1541  	forward_Query_Params_0 = runtime.ForwardResponseMessage
  1542  )