// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.1
// - protoc             v3.20.3
// source: gql_service.proto

package gql

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	SessionService_Handshake_FullMethodName = "/gql.SessionService/Handshake"
	SessionService_Configure_FullMethodName = "/gql.SessionService/Configure"
	SessionService_Reset_FullMethodName     = "/gql.SessionService/Reset"
	SessionService_Close_FullMethodName     = "/gql.SessionService/Close"
	SessionService_Ping_FullMethodName      = "/gql.SessionService/Ping"
)

// SessionServiceClient is the client API for SessionService 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 SessionServiceClient interface {
	// Establish a session. Negotiates protocol version and authenticates.
	Handshake(ctx context.Context, in *HandshakeRequest, opts ...grpc.CallOption) (*HandshakeResponse, error)
	// Configure session state (schema, graph, timezone, parameters).
	Configure(ctx context.Context, in *ConfigureRequest, opts ...grpc.CallOption) (*ConfigureResponse, error)
	// Reset session state to defaults.
	Reset(ctx context.Context, in *ResetRequest, opts ...grpc.CallOption) (*ResetResponse, error)
	// Terminate the session. Rolls back any active transaction.
	Close(ctx context.Context, in *CloseRequest, opts ...grpc.CallOption) (*CloseResponse, error)
	// Health check and keepalive.
	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error)
}

type sessionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSessionServiceClient(cc grpc.ClientConnInterface) SessionServiceClient {
	return &sessionServiceClient{cc}
}

func (c *sessionServiceClient) Handshake(ctx context.Context, in *HandshakeRequest, opts ...grpc.CallOption) (*HandshakeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(HandshakeResponse)
	err := c.cc.Invoke(ctx, SessionService_Handshake_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sessionServiceClient) Configure(ctx context.Context, in *ConfigureRequest, opts ...grpc.CallOption) (*ConfigureResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConfigureResponse)
	err := c.cc.Invoke(ctx, SessionService_Configure_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sessionServiceClient) Reset(ctx context.Context, in *ResetRequest, opts ...grpc.CallOption) (*ResetResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResetResponse)
	err := c.cc.Invoke(ctx, SessionService_Reset_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sessionServiceClient) Close(ctx context.Context, in *CloseRequest, opts ...grpc.CallOption) (*CloseResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CloseResponse)
	err := c.cc.Invoke(ctx, SessionService_Close_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sessionServiceClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PongResponse)
	err := c.cc.Invoke(ctx, SessionService_Ping_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SessionServiceServer is the server API for SessionService service.
// All implementations must embed UnimplementedSessionServiceServer
// for forward compatibility.
type SessionServiceServer interface {
	// Establish a session. Negotiates protocol version and authenticates.
	Handshake(context.Context, *HandshakeRequest) (*HandshakeResponse, error)
	// Configure session state (schema, graph, timezone, parameters).
	Configure(context.Context, *ConfigureRequest) (*ConfigureResponse, error)
	// Reset session state to defaults.
	Reset(context.Context, *ResetRequest) (*ResetResponse, error)
	// Terminate the session. Rolls back any active transaction.
	Close(context.Context, *CloseRequest) (*CloseResponse, error)
	// Health check and keepalive.
	Ping(context.Context, *PingRequest) (*PongResponse, error)
	mustEmbedUnimplementedSessionServiceServer()
}

// UnimplementedSessionServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedSessionServiceServer struct{}

func (UnimplementedSessionServiceServer) Handshake(context.Context, *HandshakeRequest) (*HandshakeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Handshake not implemented")
}
func (UnimplementedSessionServiceServer) Configure(context.Context, *ConfigureRequest) (*ConfigureResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Configure not implemented")
}
func (UnimplementedSessionServiceServer) Reset(context.Context, *ResetRequest) (*ResetResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Reset not implemented")
}
func (UnimplementedSessionServiceServer) Close(context.Context, *CloseRequest) (*CloseResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Close not implemented")
}
func (UnimplementedSessionServiceServer) Ping(context.Context, *PingRequest) (*PongResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Ping not implemented")
}
func (UnimplementedSessionServiceServer) mustEmbedUnimplementedSessionServiceServer() {}
func (UnimplementedSessionServiceServer) testEmbeddedByValue()                        {}

// UnsafeSessionServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to SessionServiceServer will
// result in compilation errors.
type UnsafeSessionServiceServer interface {
	mustEmbedUnimplementedSessionServiceServer()
}

func RegisterSessionServiceServer(s grpc.ServiceRegistrar, srv SessionServiceServer) {
	// If the following call panics, it indicates UnimplementedSessionServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&SessionService_ServiceDesc, srv)
}

func _SessionService_Handshake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HandshakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionServiceServer).Handshake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SessionService_Handshake_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionServiceServer).Handshake(ctx, req.(*HandshakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SessionService_Configure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfigureRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionServiceServer).Configure(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SessionService_Configure_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionServiceServer).Configure(ctx, req.(*ConfigureRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SessionService_Reset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionServiceServer).Reset(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SessionService_Reset_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionServiceServer).Reset(ctx, req.(*ResetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SessionService_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CloseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionServiceServer).Close(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SessionService_Close_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionServiceServer).Close(ctx, req.(*CloseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SessionService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionServiceServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SessionService_Ping_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionServiceServer).Ping(ctx, req.(*PingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SessionService_ServiceDesc is the grpc.ServiceDesc for SessionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SessionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gql.SessionService",
	HandlerType: (*SessionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Handshake",
			Handler:    _SessionService_Handshake_Handler,
		},
		{
			MethodName: "Configure",
			Handler:    _SessionService_Configure_Handler,
		},
		{
			MethodName: "Reset",
			Handler:    _SessionService_Reset_Handler,
		},
		{
			MethodName: "Close",
			Handler:    _SessionService_Close_Handler,
		},
		{
			MethodName: "Ping",
			Handler:    _SessionService_Ping_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gql_service.proto",
}

const (
	GqlService_Execute_FullMethodName          = "/gql.GqlService/Execute"
	GqlService_BeginTransaction_FullMethodName = "/gql.GqlService/BeginTransaction"
	GqlService_Commit_FullMethodName           = "/gql.GqlService/Commit"
	GqlService_Rollback_FullMethodName         = "/gql.GqlService/Rollback"
)

// GqlServiceClient is the client API for GqlService 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 GqlServiceClient interface {
	// Execute any GQL statement. Returns a stream of response frames:
	//  1. ResultHeader  (column metadata or result type indicator)
	//  2. RowBatch*     (zero or more batches of rows)
	//  3. ResultSummary (completion status, row count, diagnostics)
	Execute(ctx context.Context, in *ExecuteRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ExecuteResponse], error)
	// Begin an explicit transaction.
	BeginTransaction(ctx context.Context, in *BeginRequest, opts ...grpc.CallOption) (*BeginResponse, error)
	// Commit the active transaction.
	Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error)
	// Roll back the active transaction.
	Rollback(ctx context.Context, in *RollbackRequest, opts ...grpc.CallOption) (*RollbackResponse, error)
}

type gqlServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGqlServiceClient(cc grpc.ClientConnInterface) GqlServiceClient {
	return &gqlServiceClient{cc}
}

func (c *gqlServiceClient) Execute(ctx context.Context, in *ExecuteRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ExecuteResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &GqlService_ServiceDesc.Streams[0], GqlService_Execute_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ExecuteRequest, ExecuteResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GqlService_ExecuteClient = grpc.ServerStreamingClient[ExecuteResponse]

func (c *gqlServiceClient) BeginTransaction(ctx context.Context, in *BeginRequest, opts ...grpc.CallOption) (*BeginResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BeginResponse)
	err := c.cc.Invoke(ctx, GqlService_BeginTransaction_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gqlServiceClient) Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CommitResponse)
	err := c.cc.Invoke(ctx, GqlService_Commit_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gqlServiceClient) Rollback(ctx context.Context, in *RollbackRequest, opts ...grpc.CallOption) (*RollbackResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RollbackResponse)
	err := c.cc.Invoke(ctx, GqlService_Rollback_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GqlServiceServer is the server API for GqlService service.
// All implementations must embed UnimplementedGqlServiceServer
// for forward compatibility.
type GqlServiceServer interface {
	// Execute any GQL statement. Returns a stream of response frames:
	//  1. ResultHeader  (column metadata or result type indicator)
	//  2. RowBatch*     (zero or more batches of rows)
	//  3. ResultSummary (completion status, row count, diagnostics)
	Execute(*ExecuteRequest, grpc.ServerStreamingServer[ExecuteResponse]) error
	// Begin an explicit transaction.
	BeginTransaction(context.Context, *BeginRequest) (*BeginResponse, error)
	// Commit the active transaction.
	Commit(context.Context, *CommitRequest) (*CommitResponse, error)
	// Roll back the active transaction.
	Rollback(context.Context, *RollbackRequest) (*RollbackResponse, error)
	mustEmbedUnimplementedGqlServiceServer()
}

// UnimplementedGqlServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedGqlServiceServer struct{}

func (UnimplementedGqlServiceServer) Execute(*ExecuteRequest, grpc.ServerStreamingServer[ExecuteResponse]) error {
	return status.Error(codes.Unimplemented, "method Execute not implemented")
}
func (UnimplementedGqlServiceServer) BeginTransaction(context.Context, *BeginRequest) (*BeginResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method BeginTransaction not implemented")
}
func (UnimplementedGqlServiceServer) Commit(context.Context, *CommitRequest) (*CommitResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Commit not implemented")
}
func (UnimplementedGqlServiceServer) Rollback(context.Context, *RollbackRequest) (*RollbackResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Rollback not implemented")
}
func (UnimplementedGqlServiceServer) mustEmbedUnimplementedGqlServiceServer() {}
func (UnimplementedGqlServiceServer) testEmbeddedByValue()                    {}

// UnsafeGqlServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GqlServiceServer will
// result in compilation errors.
type UnsafeGqlServiceServer interface {
	mustEmbedUnimplementedGqlServiceServer()
}

func RegisterGqlServiceServer(s grpc.ServiceRegistrar, srv GqlServiceServer) {
	// If the following call panics, it indicates UnimplementedGqlServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&GqlService_ServiceDesc, srv)
}

func _GqlService_Execute_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ExecuteRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(GqlServiceServer).Execute(m, &grpc.GenericServerStream[ExecuteRequest, ExecuteResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GqlService_ExecuteServer = grpc.ServerStreamingServer[ExecuteResponse]

func _GqlService_BeginTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BeginRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GqlServiceServer).BeginTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GqlService_BeginTransaction_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GqlServiceServer).BeginTransaction(ctx, req.(*BeginRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GqlService_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GqlServiceServer).Commit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GqlService_Commit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GqlServiceServer).Commit(ctx, req.(*CommitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GqlService_Rollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RollbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GqlServiceServer).Rollback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GqlService_Rollback_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GqlServiceServer).Rollback(ctx, req.(*RollbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GqlService_ServiceDesc is the grpc.ServiceDesc for GqlService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GqlService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gql.GqlService",
	HandlerType: (*GqlServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "BeginTransaction",
			Handler:    _GqlService_BeginTransaction_Handler,
		},
		{
			MethodName: "Commit",
			Handler:    _GqlService_Commit_Handler,
		},
		{
			MethodName: "Rollback",
			Handler:    _GqlService_Rollback_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Execute",
			Handler:       _GqlService_Execute_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "gql_service.proto",
}

const (
	CatalogService_ListSchemas_FullMethodName     = "/gql.CatalogService/ListSchemas"
	CatalogService_CreateSchema_FullMethodName    = "/gql.CatalogService/CreateSchema"
	CatalogService_DropSchema_FullMethodName      = "/gql.CatalogService/DropSchema"
	CatalogService_ListGraphs_FullMethodName      = "/gql.CatalogService/ListGraphs"
	CatalogService_CreateGraph_FullMethodName     = "/gql.CatalogService/CreateGraph"
	CatalogService_DropGraph_FullMethodName       = "/gql.CatalogService/DropGraph"
	CatalogService_GetGraphInfo_FullMethodName    = "/gql.CatalogService/GetGraphInfo"
	CatalogService_ListGraphTypes_FullMethodName  = "/gql.CatalogService/ListGraphTypes"
	CatalogService_CreateGraphType_FullMethodName = "/gql.CatalogService/CreateGraphType"
	CatalogService_DropGraphType_FullMethodName   = "/gql.CatalogService/DropGraphType"
)

// CatalogServiceClient is the client API for CatalogService 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 CatalogServiceClient interface {
	// Schema management (sec 12.2, 12.3 - Feature GC01)
	ListSchemas(ctx context.Context, in *ListSchemasRequest, opts ...grpc.CallOption) (*ListSchemasResponse, error)
	CreateSchema(ctx context.Context, in *CreateSchemaRequest, opts ...grpc.CallOption) (*CreateSchemaResponse, error)
	DropSchema(ctx context.Context, in *DropSchemaRequest, opts ...grpc.CallOption) (*DropSchemaResponse, error)
	// Graph management (sec 12.4, 12.5 - Feature GC04)
	ListGraphs(ctx context.Context, in *ListGraphsRequest, opts ...grpc.CallOption) (*ListGraphsResponse, error)
	CreateGraph(ctx context.Context, in *CreateGraphRequest, opts ...grpc.CallOption) (*CreateGraphResponse, error)
	DropGraph(ctx context.Context, in *DropGraphRequest, opts ...grpc.CallOption) (*DropGraphResponse, error)
	GetGraphInfo(ctx context.Context, in *GetGraphInfoRequest, opts ...grpc.CallOption) (*GetGraphInfoResponse, error)
	// Graph type management (sec 12.6, 12.7 - Feature GG02)
	ListGraphTypes(ctx context.Context, in *ListGraphTypesRequest, opts ...grpc.CallOption) (*ListGraphTypesResponse, error)
	CreateGraphType(ctx context.Context, in *CreateGraphTypeRequest, opts ...grpc.CallOption) (*CreateGraphTypeResponse, error)
	DropGraphType(ctx context.Context, in *DropGraphTypeRequest, opts ...grpc.CallOption) (*DropGraphTypeResponse, error)
}

type catalogServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCatalogServiceClient(cc grpc.ClientConnInterface) CatalogServiceClient {
	return &catalogServiceClient{cc}
}

func (c *catalogServiceClient) ListSchemas(ctx context.Context, in *ListSchemasRequest, opts ...grpc.CallOption) (*ListSchemasResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSchemasResponse)
	err := c.cc.Invoke(ctx, CatalogService_ListSchemas_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) CreateSchema(ctx context.Context, in *CreateSchemaRequest, opts ...grpc.CallOption) (*CreateSchemaResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateSchemaResponse)
	err := c.cc.Invoke(ctx, CatalogService_CreateSchema_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) DropSchema(ctx context.Context, in *DropSchemaRequest, opts ...grpc.CallOption) (*DropSchemaResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DropSchemaResponse)
	err := c.cc.Invoke(ctx, CatalogService_DropSchema_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) ListGraphs(ctx context.Context, in *ListGraphsRequest, opts ...grpc.CallOption) (*ListGraphsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListGraphsResponse)
	err := c.cc.Invoke(ctx, CatalogService_ListGraphs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) CreateGraph(ctx context.Context, in *CreateGraphRequest, opts ...grpc.CallOption) (*CreateGraphResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateGraphResponse)
	err := c.cc.Invoke(ctx, CatalogService_CreateGraph_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) DropGraph(ctx context.Context, in *DropGraphRequest, opts ...grpc.CallOption) (*DropGraphResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DropGraphResponse)
	err := c.cc.Invoke(ctx, CatalogService_DropGraph_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) GetGraphInfo(ctx context.Context, in *GetGraphInfoRequest, opts ...grpc.CallOption) (*GetGraphInfoResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetGraphInfoResponse)
	err := c.cc.Invoke(ctx, CatalogService_GetGraphInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) ListGraphTypes(ctx context.Context, in *ListGraphTypesRequest, opts ...grpc.CallOption) (*ListGraphTypesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListGraphTypesResponse)
	err := c.cc.Invoke(ctx, CatalogService_ListGraphTypes_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) CreateGraphType(ctx context.Context, in *CreateGraphTypeRequest, opts ...grpc.CallOption) (*CreateGraphTypeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateGraphTypeResponse)
	err := c.cc.Invoke(ctx, CatalogService_CreateGraphType_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *catalogServiceClient) DropGraphType(ctx context.Context, in *DropGraphTypeRequest, opts ...grpc.CallOption) (*DropGraphTypeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DropGraphTypeResponse)
	err := c.cc.Invoke(ctx, CatalogService_DropGraphType_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CatalogServiceServer is the server API for CatalogService service.
// All implementations must embed UnimplementedCatalogServiceServer
// for forward compatibility.
type CatalogServiceServer interface {
	// Schema management (sec 12.2, 12.3 - Feature GC01)
	ListSchemas(context.Context, *ListSchemasRequest) (*ListSchemasResponse, error)
	CreateSchema(context.Context, *CreateSchemaRequest) (*CreateSchemaResponse, error)
	DropSchema(context.Context, *DropSchemaRequest) (*DropSchemaResponse, error)
	// Graph management (sec 12.4, 12.5 - Feature GC04)
	ListGraphs(context.Context, *ListGraphsRequest) (*ListGraphsResponse, error)
	CreateGraph(context.Context, *CreateGraphRequest) (*CreateGraphResponse, error)
	DropGraph(context.Context, *DropGraphRequest) (*DropGraphResponse, error)
	GetGraphInfo(context.Context, *GetGraphInfoRequest) (*GetGraphInfoResponse, error)
	// Graph type management (sec 12.6, 12.7 - Feature GG02)
	ListGraphTypes(context.Context, *ListGraphTypesRequest) (*ListGraphTypesResponse, error)
	CreateGraphType(context.Context, *CreateGraphTypeRequest) (*CreateGraphTypeResponse, error)
	DropGraphType(context.Context, *DropGraphTypeRequest) (*DropGraphTypeResponse, error)
	mustEmbedUnimplementedCatalogServiceServer()
}

// UnimplementedCatalogServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedCatalogServiceServer struct{}

func (UnimplementedCatalogServiceServer) ListSchemas(context.Context, *ListSchemasRequest) (*ListSchemasResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListSchemas not implemented")
}
func (UnimplementedCatalogServiceServer) CreateSchema(context.Context, *CreateSchemaRequest) (*CreateSchemaResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateSchema not implemented")
}
func (UnimplementedCatalogServiceServer) DropSchema(context.Context, *DropSchemaRequest) (*DropSchemaResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DropSchema not implemented")
}
func (UnimplementedCatalogServiceServer) ListGraphs(context.Context, *ListGraphsRequest) (*ListGraphsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListGraphs not implemented")
}
func (UnimplementedCatalogServiceServer) CreateGraph(context.Context, *CreateGraphRequest) (*CreateGraphResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateGraph not implemented")
}
func (UnimplementedCatalogServiceServer) DropGraph(context.Context, *DropGraphRequest) (*DropGraphResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DropGraph not implemented")
}
func (UnimplementedCatalogServiceServer) GetGraphInfo(context.Context, *GetGraphInfoRequest) (*GetGraphInfoResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetGraphInfo not implemented")
}
func (UnimplementedCatalogServiceServer) ListGraphTypes(context.Context, *ListGraphTypesRequest) (*ListGraphTypesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListGraphTypes not implemented")
}
func (UnimplementedCatalogServiceServer) CreateGraphType(context.Context, *CreateGraphTypeRequest) (*CreateGraphTypeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateGraphType not implemented")
}
func (UnimplementedCatalogServiceServer) DropGraphType(context.Context, *DropGraphTypeRequest) (*DropGraphTypeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DropGraphType not implemented")
}
func (UnimplementedCatalogServiceServer) mustEmbedUnimplementedCatalogServiceServer() {}
func (UnimplementedCatalogServiceServer) testEmbeddedByValue()                        {}

// UnsafeCatalogServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to CatalogServiceServer will
// result in compilation errors.
type UnsafeCatalogServiceServer interface {
	mustEmbedUnimplementedCatalogServiceServer()
}

func RegisterCatalogServiceServer(s grpc.ServiceRegistrar, srv CatalogServiceServer) {
	// If the following call panics, it indicates UnimplementedCatalogServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&CatalogService_ServiceDesc, srv)
}

func _CatalogService_ListSchemas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSchemasRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).ListSchemas(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_ListSchemas_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).ListSchemas(ctx, req.(*ListSchemasRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_CreateSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).CreateSchema(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_CreateSchema_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).CreateSchema(ctx, req.(*CreateSchemaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_DropSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DropSchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).DropSchema(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_DropSchema_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).DropSchema(ctx, req.(*DropSchemaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_ListGraphs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListGraphsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).ListGraphs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_ListGraphs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).ListGraphs(ctx, req.(*ListGraphsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_CreateGraph_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateGraphRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).CreateGraph(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_CreateGraph_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).CreateGraph(ctx, req.(*CreateGraphRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_DropGraph_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DropGraphRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).DropGraph(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_DropGraph_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).DropGraph(ctx, req.(*DropGraphRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_GetGraphInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetGraphInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).GetGraphInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_GetGraphInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).GetGraphInfo(ctx, req.(*GetGraphInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_ListGraphTypes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListGraphTypesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).ListGraphTypes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_ListGraphTypes_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).ListGraphTypes(ctx, req.(*ListGraphTypesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_CreateGraphType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateGraphTypeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).CreateGraphType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_CreateGraphType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).CreateGraphType(ctx, req.(*CreateGraphTypeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CatalogService_DropGraphType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DropGraphTypeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CatalogServiceServer).DropGraphType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CatalogService_DropGraphType_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CatalogServiceServer).DropGraphType(ctx, req.(*DropGraphTypeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// CatalogService_ServiceDesc is the grpc.ServiceDesc for CatalogService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CatalogService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gql.CatalogService",
	HandlerType: (*CatalogServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListSchemas",
			Handler:    _CatalogService_ListSchemas_Handler,
		},
		{
			MethodName: "CreateSchema",
			Handler:    _CatalogService_CreateSchema_Handler,
		},
		{
			MethodName: "DropSchema",
			Handler:    _CatalogService_DropSchema_Handler,
		},
		{
			MethodName: "ListGraphs",
			Handler:    _CatalogService_ListGraphs_Handler,
		},
		{
			MethodName: "CreateGraph",
			Handler:    _CatalogService_CreateGraph_Handler,
		},
		{
			MethodName: "DropGraph",
			Handler:    _CatalogService_DropGraph_Handler,
		},
		{
			MethodName: "GetGraphInfo",
			Handler:    _CatalogService_GetGraphInfo_Handler,
		},
		{
			MethodName: "ListGraphTypes",
			Handler:    _CatalogService_ListGraphTypes_Handler,
		},
		{
			MethodName: "CreateGraphType",
			Handler:    _CatalogService_CreateGraphType_Handler,
		},
		{
			MethodName: "DropGraphType",
			Handler:    _CatalogService_DropGraphType_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gql_service.proto",
}

const (
	AdminService_GetGraphStats_FullMethodName = "/gql.AdminService/GetGraphStats"
	AdminService_WalStatus_FullMethodName     = "/gql.AdminService/WalStatus"
	AdminService_WalCheckpoint_FullMethodName = "/gql.AdminService/WalCheckpoint"
	AdminService_Validate_FullMethodName      = "/gql.AdminService/Validate"
	AdminService_CreateIndex_FullMethodName   = "/gql.AdminService/CreateIndex"
	AdminService_DropIndex_FullMethodName     = "/gql.AdminService/DropIndex"
)

// AdminServiceClient is the client API for AdminService 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 AdminServiceClient interface {
	// Get detailed graph statistics (counts, memory, disk, indexes).
	GetGraphStats(ctx context.Context, in *GetGraphStatsRequest, opts ...grpc.CallOption) (*GetGraphStatsResponse, error)
	// Get WAL (Write-Ahead Log) status.
	WalStatus(ctx context.Context, in *WalStatusRequest, opts ...grpc.CallOption) (*WalStatusResponse, error)
	// Force a WAL checkpoint (flush pending records to storage).
	WalCheckpoint(ctx context.Context, in *WalCheckpointRequest, opts ...grpc.CallOption) (*WalCheckpointResponse, error)
	// Validate graph integrity (dangling edges, index consistency).
	Validate(ctx context.Context, in *ValidateRequest, opts ...grpc.CallOption) (*ValidateResponse, error)
	// Create an index (property, vector, or text).
	CreateIndex(ctx context.Context, in *CreateIndexRequest, opts ...grpc.CallOption) (*CreateIndexResponse, error)
	// Drop an index.
	DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*DropIndexResponse, error)
}

type adminServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminServiceClient(cc grpc.ClientConnInterface) AdminServiceClient {
	return &adminServiceClient{cc}
}

func (c *adminServiceClient) GetGraphStats(ctx context.Context, in *GetGraphStatsRequest, opts ...grpc.CallOption) (*GetGraphStatsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetGraphStatsResponse)
	err := c.cc.Invoke(ctx, AdminService_GetGraphStats_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminServiceClient) WalStatus(ctx context.Context, in *WalStatusRequest, opts ...grpc.CallOption) (*WalStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(WalStatusResponse)
	err := c.cc.Invoke(ctx, AdminService_WalStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminServiceClient) WalCheckpoint(ctx context.Context, in *WalCheckpointRequest, opts ...grpc.CallOption) (*WalCheckpointResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(WalCheckpointResponse)
	err := c.cc.Invoke(ctx, AdminService_WalCheckpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminServiceClient) Validate(ctx context.Context, in *ValidateRequest, opts ...grpc.CallOption) (*ValidateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ValidateResponse)
	err := c.cc.Invoke(ctx, AdminService_Validate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminServiceClient) CreateIndex(ctx context.Context, in *CreateIndexRequest, opts ...grpc.CallOption) (*CreateIndexResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateIndexResponse)
	err := c.cc.Invoke(ctx, AdminService_CreateIndex_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminServiceClient) DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*DropIndexResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DropIndexResponse)
	err := c.cc.Invoke(ctx, AdminService_DropIndex_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminServiceServer is the server API for AdminService service.
// All implementations must embed UnimplementedAdminServiceServer
// for forward compatibility.
type AdminServiceServer interface {
	// Get detailed graph statistics (counts, memory, disk, indexes).
	GetGraphStats(context.Context, *GetGraphStatsRequest) (*GetGraphStatsResponse, error)
	// Get WAL (Write-Ahead Log) status.
	WalStatus(context.Context, *WalStatusRequest) (*WalStatusResponse, error)
	// Force a WAL checkpoint (flush pending records to storage).
	WalCheckpoint(context.Context, *WalCheckpointRequest) (*WalCheckpointResponse, error)
	// Validate graph integrity (dangling edges, index consistency).
	Validate(context.Context, *ValidateRequest) (*ValidateResponse, error)
	// Create an index (property, vector, or text).
	CreateIndex(context.Context, *CreateIndexRequest) (*CreateIndexResponse, error)
	// Drop an index.
	DropIndex(context.Context, *DropIndexRequest) (*DropIndexResponse, error)
	mustEmbedUnimplementedAdminServiceServer()
}

// UnimplementedAdminServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedAdminServiceServer struct{}

func (UnimplementedAdminServiceServer) GetGraphStats(context.Context, *GetGraphStatsRequest) (*GetGraphStatsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetGraphStats not implemented")
}
func (UnimplementedAdminServiceServer) WalStatus(context.Context, *WalStatusRequest) (*WalStatusResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method WalStatus not implemented")
}
func (UnimplementedAdminServiceServer) WalCheckpoint(context.Context, *WalCheckpointRequest) (*WalCheckpointResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method WalCheckpoint not implemented")
}
func (UnimplementedAdminServiceServer) Validate(context.Context, *ValidateRequest) (*ValidateResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method Validate not implemented")
}
func (UnimplementedAdminServiceServer) CreateIndex(context.Context, *CreateIndexRequest) (*CreateIndexResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateIndex not implemented")
}
func (UnimplementedAdminServiceServer) DropIndex(context.Context, *DropIndexRequest) (*DropIndexResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DropIndex not implemented")
}
func (UnimplementedAdminServiceServer) mustEmbedUnimplementedAdminServiceServer() {}
func (UnimplementedAdminServiceServer) testEmbeddedByValue()                      {}

// UnsafeAdminServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AdminServiceServer will
// result in compilation errors.
type UnsafeAdminServiceServer interface {
	mustEmbedUnimplementedAdminServiceServer()
}

func RegisterAdminServiceServer(s grpc.ServiceRegistrar, srv AdminServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&AdminService_ServiceDesc, srv)
}

func _AdminService_GetGraphStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetGraphStatsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminServiceServer).GetGraphStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminService_GetGraphStats_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminServiceServer).GetGraphStats(ctx, req.(*GetGraphStatsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminService_WalStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WalStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminServiceServer).WalStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminService_WalStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminServiceServer).WalStatus(ctx, req.(*WalStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminService_WalCheckpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WalCheckpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminServiceServer).WalCheckpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminService_WalCheckpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminServiceServer).WalCheckpoint(ctx, req.(*WalCheckpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminService_Validate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminServiceServer).Validate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminService_Validate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminServiceServer).Validate(ctx, req.(*ValidateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminService_CreateIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminServiceServer).CreateIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminService_CreateIndex_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminServiceServer).CreateIndex(ctx, req.(*CreateIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminService_DropIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DropIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminServiceServer).DropIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminService_DropIndex_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminServiceServer).DropIndex(ctx, req.(*DropIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminService_ServiceDesc is the grpc.ServiceDesc for AdminService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gql.AdminService",
	HandlerType: (*AdminServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetGraphStats",
			Handler:    _AdminService_GetGraphStats_Handler,
		},
		{
			MethodName: "WalStatus",
			Handler:    _AdminService_WalStatus_Handler,
		},
		{
			MethodName: "WalCheckpoint",
			Handler:    _AdminService_WalCheckpoint_Handler,
		},
		{
			MethodName: "Validate",
			Handler:    _AdminService_Validate_Handler,
		},
		{
			MethodName: "CreateIndex",
			Handler:    _AdminService_CreateIndex_Handler,
		},
		{
			MethodName: "DropIndex",
			Handler:    _AdminService_DropIndex_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gql_service.proto",
}

const (
	SearchService_VectorSearch_FullMethodName = "/gql.SearchService/VectorSearch"
	SearchService_TextSearch_FullMethodName   = "/gql.SearchService/TextSearch"
	SearchService_HybridSearch_FullMethodName = "/gql.SearchService/HybridSearch"
)

// SearchServiceClient is the client API for SearchService 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 SearchServiceClient interface {
	// Vector similarity search (KNN via HNSW index).
	VectorSearch(ctx context.Context, in *VectorSearchRequest, opts ...grpc.CallOption) (*VectorSearchResponse, error)
	// Full-text search (BM25 scoring).
	TextSearch(ctx context.Context, in *TextSearchRequest, opts ...grpc.CallOption) (*TextSearchResponse, error)
	// Hybrid search combining text and vector results with rank fusion.
	HybridSearch(ctx context.Context, in *HybridSearchRequest, opts ...grpc.CallOption) (*HybridSearchResponse, error)
}

type searchServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSearchServiceClient(cc grpc.ClientConnInterface) SearchServiceClient {
	return &searchServiceClient{cc}
}

func (c *searchServiceClient) VectorSearch(ctx context.Context, in *VectorSearchRequest, opts ...grpc.CallOption) (*VectorSearchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(VectorSearchResponse)
	err := c.cc.Invoke(ctx, SearchService_VectorSearch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *searchServiceClient) TextSearch(ctx context.Context, in *TextSearchRequest, opts ...grpc.CallOption) (*TextSearchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TextSearchResponse)
	err := c.cc.Invoke(ctx, SearchService_TextSearch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *searchServiceClient) HybridSearch(ctx context.Context, in *HybridSearchRequest, opts ...grpc.CallOption) (*HybridSearchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(HybridSearchResponse)
	err := c.cc.Invoke(ctx, SearchService_HybridSearch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SearchServiceServer is the server API for SearchService service.
// All implementations must embed UnimplementedSearchServiceServer
// for forward compatibility.
type SearchServiceServer interface {
	// Vector similarity search (KNN via HNSW index).
	VectorSearch(context.Context, *VectorSearchRequest) (*VectorSearchResponse, error)
	// Full-text search (BM25 scoring).
	TextSearch(context.Context, *TextSearchRequest) (*TextSearchResponse, error)
	// Hybrid search combining text and vector results with rank fusion.
	HybridSearch(context.Context, *HybridSearchRequest) (*HybridSearchResponse, error)
	mustEmbedUnimplementedSearchServiceServer()
}

// UnimplementedSearchServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedSearchServiceServer struct{}

func (UnimplementedSearchServiceServer) VectorSearch(context.Context, *VectorSearchRequest) (*VectorSearchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method VectorSearch not implemented")
}
func (UnimplementedSearchServiceServer) TextSearch(context.Context, *TextSearchRequest) (*TextSearchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method TextSearch not implemented")
}
func (UnimplementedSearchServiceServer) HybridSearch(context.Context, *HybridSearchRequest) (*HybridSearchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method HybridSearch not implemented")
}
func (UnimplementedSearchServiceServer) mustEmbedUnimplementedSearchServiceServer() {}
func (UnimplementedSearchServiceServer) testEmbeddedByValue()                       {}

// UnsafeSearchServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to SearchServiceServer will
// result in compilation errors.
type UnsafeSearchServiceServer interface {
	mustEmbedUnimplementedSearchServiceServer()
}

func RegisterSearchServiceServer(s grpc.ServiceRegistrar, srv SearchServiceServer) {
	// If the following call panics, it indicates UnimplementedSearchServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&SearchService_ServiceDesc, srv)
}

func _SearchService_VectorSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VectorSearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SearchServiceServer).VectorSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SearchService_VectorSearch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SearchServiceServer).VectorSearch(ctx, req.(*VectorSearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SearchService_TextSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TextSearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SearchServiceServer).TextSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SearchService_TextSearch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SearchServiceServer).TextSearch(ctx, req.(*TextSearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SearchService_HybridSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HybridSearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SearchServiceServer).HybridSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SearchService_HybridSearch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SearchServiceServer).HybridSearch(ctx, req.(*HybridSearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SearchService_ServiceDesc is the grpc.ServiceDesc for SearchService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SearchService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gql.SearchService",
	HandlerType: (*SearchServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "VectorSearch",
			Handler:    _SearchService_VectorSearch_Handler,
		},
		{
			MethodName: "TextSearch",
			Handler:    _SearchService_TextSearch_Handler,
		},
		{
			MethodName: "HybridSearch",
			Handler:    _SearchService_HybridSearch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "gql_service.proto",
}
