session

type ChannelPool interface {
	Close() error
}

type Client interface {
	// OpenTable returns a TableAPI for a standard table,
	// identified by the leaf table name (e.g. "my-table"). Full
	// resource composition happens inside the implementation.
	OpenTable(tableID string) TableAPI

	// OpenAuthorizedView returns a TableAPI for a specific
	// authorized view under `table`.
	OpenAuthorizedView(table, view string) TableAPI

	// OpenMaterializedView returns a read-only TableAPI for a
	// materialized view. MutateRow on the returned handle errors.
	OpenMaterializedView(view string) TableAPI

	// MeterProvider exposes the OpenTelemetry meter provider the
	// Client was constructed with — same instance the
	// bigtable client uses for its own metrics, so callers can
	// register additional instruments against the same provider.
	MeterProvider() metric.MeterProvider

	// SessionDebug / ChannelDebug / ConfigDebug expose the debug-page
	// data surfaces. Together they satisfy the same shape
	// debugview.DebugProviders needs, so a Client (or a public
	// wrapper composed of one) can be handed to debugview.Handler
	// without an adapter. Diverter() on the returned SessionDebugProvider
	// is empty for standalone session.Client — the classic/session
	// split is a mixed-mode concept that only makes sense on a
	// bigtable.Client that also owns a classic pool.
	SessionDebug() btransport.SessionDebugProvider
	ChannelDebug() btransport.ChannelDebugProvider
	ConfigDebug() btransport.ConfigDebugProvider

	// AddSessionLoadListener registers a listener invoked every time
	// the server-driven ClientConfigurationManager reports a new
	// session-load ratio (0.0 = classic-only, 1.0 = session-only).
	// Returns an unregister thunk. Used by mixed-mode bigtable.Client
	// to feed its Diverter; standalone session.Client callers can
	// ignore this method.
	AddSessionLoadListener(func(load float64)) func()

	// Close closes the underlying channel pool. TableAPI
	// instances previously vended become unusable.
	Close() error
}

type Config struct {
	// Project / Instance / AppProfile identify the target resource
	// and get baked into resource-name composition + request-params.
	Project    string
	Instance   string
	AppProfile string

	// FeatureFlagsMD is merged into per-pool routing metadata.
	FeatureFlagsMD metadata.MD

	// ConfigMD is the metadata attached to the ClientConfigurationManager's
	// GetClientConfiguration polls — instance-scoped headers.
	ConfigMD metadata.MD

	// MetricsEnabled mirrors the SessionManager boolean of the same
	// name; propagates into FeatureFlags on every OpenSessionRequest.
	MetricsEnabled bool

	// FeatureFlagsProto is the pre-built FeatureFlags proto stamped
	// onto every OpenSessionRequest.Flags. Required — callers MUST
	// populate this with the same proto they marshaled into
	// FeatureFlagsMD so header and envelope are byte-identical (the
	// server rejects OpenSession with INVALID_ARGUMENT on mismatch).
	FeatureFlagsProto *btpb.FeatureFlags

	// SessionLoadListener is invoked whenever the server-driven
	// ClientConfigurationManager reports a new session-load ratio. The
	// bigtable Client wires this to Diverter.SetSessionLoad so the
	// classic/session traffic split follows the server's directive.
	SessionLoadListener func(load float64)

	// BackgroundCtx is the parent context for the Client's own
	// process-lifetime loops (today: ClientConfigurationManager polling).
	// Cancelled by Client teardown.
	//
	// Deliberately NOT handed to session pools. A pool's lifetime is a
	// strict subset of this Client's: Close() closes every pool, and
	// session.TableCache also evicts + Closes individual pools while the
	// Client keeps running. So this ctx is always too coarse to scope
	// pool-owned work — it can only ever fire after the pool is already
	// gone (client shutdown), or never at all (TTL eviction). Either way
	// the pool's loops outlive its Close, and since each loop closure
	// captures the pool, the pool itself stays reachable. Pools scope
	// their own goroutines; see SessionPoolImpl.Start / maintCtx.
	BackgroundCtx context.Context

	// EnableDebug controls whether the pools this Client mints will
	// collect per-pool snapshot state (sessionz / afez / flightz /
	// loadz). Default false. When false, every allocating debug
	// recorder in the pool is skipped for zero hot-path overhead —
	// no per-session events ring, no latency-sample buffers, no
	// per-pick candidate slices, no pool-wide histogram inserts, no
	// slow-vRPC log entries. SessionDebug() also returns nil so the
	// debugview handler renders a "not enabled" panel.
	//
	// Callers that plan to serve /debug/ from bigtable/debugview or
	// scrape session snapshots programmatically should set this true;
	// production workloads that only care about the OTel metrics
	// (attempt_latencies / operation_latencies / etc.) can leave it
	// off. The debug surface is otherwise unchanged; flipping the
	// flag on or off requires rebuilding the client.
	EnableDebug bool
}

type DebugAccess interface {
	// PoolSnapshots returns one PoolSnapshot per owned pool, ordered
	// by pool key. Feeds sessionz.
	PoolSnapshots() []btransport.PoolSnapshot
	// LoadBalancingSnapshots returns per-pool picker + pick-history
	// snapshots. Feeds loadz.
	LoadBalancingSnapshots() []btransport.LoadBalancingSnapshot
	// ChannelPool returns the *BigtableChannelPool the Client
	// was constructed with, or nil.
	ChannelPool() *btransport.BigtableChannelPool
	// ConfigManager returns the internal ClientConfigurationManager
	// for configz. Nil when no stub was provided at construction.
	ConfigManager() *btransport.ClientConfigurationManager
}

type Invoker interface {
	Invoke(ctx context.Context, desc btransport.VRpcDescriptor, req interface{}) (btransport.InvokeResult, error)
}

type TableAPI interface {
	ReadRow(ctx context.Context, req *btpb.SessionReadRowRequest) (*btpb.SessionReadRowResponse, error)
	MutateRow(ctx context.Context, req *btpb.SessionMutateRowRequest) (*btpb.SessionMutateRowResponse, error)

	// Close releases this resource's underlying read + write session
	// pools from the sessionClient's per-resource keyed map. Idempotent.
	// Independent from Client.Close — closing an individual resource
	// does not close the shared channel pool.
	//
	// Per-handle pool teardown is safe because callers reach this method
	// through bigtable.Client's session.TableCache, which guarantees
	// at-most-one TableAPI per resource per Client. A future caller that
	// bypasses that cache must add a refcount before calling Close.
	Close() error
}

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

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

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