client

type ConfigLocks struct {
	Bits int
	Tags map[string]struct{}
}

type Option struct {
	F func(o *Options, di *utils.Slice)
}

type Options struct {
	Cli     *rpcinfo.EndpointBasicInfo
	Svr     *rpcinfo.EndpointBasicInfo
	Configs rpcinfo.RPCConfig
	Locks   *ConfigLocks
	Once    *configutil.OptionOnce

	UnaryOptions  UnaryOptions
	StreamOptions StreamOptions

	MetaHandlers []remote.MetaHandler

	RemoteOpt        *remote.ClientOption
	Proxy            proxy.ForwardProxy
	Resolver         discovery.Resolver
	HTTPResolver     http.Resolver
	Balancer         loadbalance.Loadbalancer
	BalancerCacheOpt *lbcache.Options
	PoolCfg          *connpool2.IdleConfig
	ErrHandle        func(context.Context, error) error
	Targets          string
	CBSuite          *circuitbreak.CBSuite
	Timeouts         rpcinfo.TimeoutProvider

	ACLRules []acl.RejectFunc

	MWBs  []endpoint.MiddlewareBuilder
	IMWBs []endpoint.MiddlewareBuilder

	Bus          event.Bus
	Events       event.Queue
	ExtraTimeout time.Duration

	// DebugInfo should only contain objects that are suitable for json serialization.
	DebugInfo    utils.Slice
	DebugService diagnosis.Service

	// Observability
	TracerCtl  *rpcinfo.TraceController
	StatsLevel *stats.Level

	CloseCallbacks []func() error
	WarmUpOption   *warmup.ClientOption

	// GRPC
	GRPCConnPoolSize uint32
	GRPCConnectOpts  *grpc.ConnectOptions

	// TTHeaderStreaming
	TTHeaderStreamingOptions TTHeaderStreamingOptions

	// XDS
	XDSEnabled          bool
	XDSRouterMiddleware endpoint.Middleware

	// Context backup
	CtxBackupHandler backup.BackupHandler

	Streaming stream.StreamingConfig // deprecated, use StreamOptions instead

	// TailOptions is used to store options that are executed after all options are applied.
	// just ignore it unless you clearly know what you are doing.
	TailOptions []Option
}

type StreamOption struct {
	F func(o *StreamOptions, di *utils.Slice)
}

type StreamOptions struct {
	EventHandler                 stream.StreamEventHandler
	RecvTimeout                  time.Duration
	StreamMiddlewares            []cep.StreamMiddleware
	StreamMiddlewareBuilders     []cep.StreamMiddlewareBuilder
	StreamRecvMiddlewares        []cep.StreamRecvMiddleware
	StreamRecvMiddlewareBuilders []cep.StreamRecvMiddlewareBuilder
	StreamSendMiddlewares        []cep.StreamSendMiddleware
	StreamSendMiddlewareBuilders []cep.StreamSendMiddlewareBuilder
}

type TTHeaderStreamingOption struct {
	F func(o *TTHeaderStreamingOptions, di *utils.Slice)
}

type TTHeaderStreamingOptions struct {
	TransportOptions []ttstream.ClientHandlerOption
}

type UnaryOption struct {
	F func(o *UnaryOptions, di *utils.Slice)
}

type UnaryOptions struct {

	// middlewares
	UnaryMiddlewares        []endpoint.UnaryMiddleware
	UnaryMiddlewareBuilders []endpoint.UnaryMiddlewareBuilder

	// retry policy
	RetryMethodPolicies map[string]retry.Policy
	RetryContainer      *retry.Container
	RetryWithResult     *retry.ShouldResultRetry

	// fallback policy
	Fallback *fallback.Policy
	// contains filtered or unexported fields
}