//  Copyright 2026 Google LLC
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.

// TODO: Here and everywhere, s/Session/Actor to align with the glossary.

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.1
// - protoc             v4.25.3
// source: ateapi.proto

package ateapipb

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 (
	Control_GetActor_FullMethodName     = "/ateapi.Control/GetActor"
	Control_CreateActor_FullMethodName  = "/ateapi.Control/CreateActor"
	Control_SuspendActor_FullMethodName = "/ateapi.Control/SuspendActor"
	Control_ResumeActor_FullMethodName  = "/ateapi.Control/ResumeActor"
	Control_DeleteActor_FullMethodName  = "/ateapi.Control/DeleteActor"
	Control_ListWorkers_FullMethodName  = "/ateapi.Control/ListWorkers"
	Control_ListActors_FullMethodName   = "/ateapi.Control/ListActors"
	Control_DebugClear_FullMethodName   = "/ateapi.Control/DebugClear"
)

// ControlClient is the client API for Control 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.
//
// Control is the primary RPC interface for Agentic Substrate.
type ControlClient interface {
	// Get an Actor.
	GetActor(ctx context.Context, in *GetActorRequest, opts ...grpc.CallOption) (*GetActorResponse, error)
	// Create a new Actor deriving from a given ActorTemplate.
	CreateActor(ctx context.Context, in *CreateActorRequest, opts ...grpc.CallOption) (*CreateActorResponse, error)
	// Suspend a given actor to a new snapshot.
	SuspendActor(ctx context.Context, in *SuspendActorRequest, opts ...grpc.CallOption) (*SuspendActorResponse, error)
	// Resume an actor from its latest snapshot.
	ResumeActor(ctx context.Context, in *ResumeActorRequest, opts ...grpc.CallOption) (*ResumeActorResponse, error)
	// Delete an actor. Only suspended actors can be deleted.
	DeleteActor(ctx context.Context, in *DeleteActorRequest, opts ...grpc.CallOption) (*DeleteActorResponse, error)
	// List all workers currently reflected in redis.
	ListWorkers(ctx context.Context, in *ListWorkersRequest, opts ...grpc.CallOption) (*ListWorkersResponse, error)
	// List all actors currently reflected in redis.
	ListActors(ctx context.Context, in *ListActorsRequest, opts ...grpc.CallOption) (*ListActorsResponse, error)
	// Debugging: drop all data from the ate database.
	DebugClear(ctx context.Context, in *DebugClearRequest, opts ...grpc.CallOption) (*DebugClearResponse, error)
}

type controlClient struct {
	cc grpc.ClientConnInterface
}

func NewControlClient(cc grpc.ClientConnInterface) ControlClient {
	return &controlClient{cc}
}

func (c *controlClient) GetActor(ctx context.Context, in *GetActorRequest, opts ...grpc.CallOption) (*GetActorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetActorResponse)
	err := c.cc.Invoke(ctx, Control_GetActor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) CreateActor(ctx context.Context, in *CreateActorRequest, opts ...grpc.CallOption) (*CreateActorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateActorResponse)
	err := c.cc.Invoke(ctx, Control_CreateActor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) SuspendActor(ctx context.Context, in *SuspendActorRequest, opts ...grpc.CallOption) (*SuspendActorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SuspendActorResponse)
	err := c.cc.Invoke(ctx, Control_SuspendActor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) ResumeActor(ctx context.Context, in *ResumeActorRequest, opts ...grpc.CallOption) (*ResumeActorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ResumeActorResponse)
	err := c.cc.Invoke(ctx, Control_ResumeActor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) DeleteActor(ctx context.Context, in *DeleteActorRequest, opts ...grpc.CallOption) (*DeleteActorResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteActorResponse)
	err := c.cc.Invoke(ctx, Control_DeleteActor_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) ListWorkers(ctx context.Context, in *ListWorkersRequest, opts ...grpc.CallOption) (*ListWorkersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListWorkersResponse)
	err := c.cc.Invoke(ctx, Control_ListWorkers_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) ListActors(ctx context.Context, in *ListActorsRequest, opts ...grpc.CallOption) (*ListActorsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListActorsResponse)
	err := c.cc.Invoke(ctx, Control_ListActors_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) DebugClear(ctx context.Context, in *DebugClearRequest, opts ...grpc.CallOption) (*DebugClearResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DebugClearResponse)
	err := c.cc.Invoke(ctx, Control_DebugClear_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ControlServer is the server API for Control service.
// All implementations must embed UnimplementedControlServer
// for forward compatibility.
//
// Control is the primary RPC interface for Agentic Substrate.
type ControlServer interface {
	// Get an Actor.
	GetActor(context.Context, *GetActorRequest) (*GetActorResponse, error)
	// Create a new Actor deriving from a given ActorTemplate.
	CreateActor(context.Context, *CreateActorRequest) (*CreateActorResponse, error)
	// Suspend a given actor to a new snapshot.
	SuspendActor(context.Context, *SuspendActorRequest) (*SuspendActorResponse, error)
	// Resume an actor from its latest snapshot.
	ResumeActor(context.Context, *ResumeActorRequest) (*ResumeActorResponse, error)
	// Delete an actor. Only suspended actors can be deleted.
	DeleteActor(context.Context, *DeleteActorRequest) (*DeleteActorResponse, error)
	// List all workers currently reflected in redis.
	ListWorkers(context.Context, *ListWorkersRequest) (*ListWorkersResponse, error)
	// List all actors currently reflected in redis.
	ListActors(context.Context, *ListActorsRequest) (*ListActorsResponse, error)
	// Debugging: drop all data from the ate database.
	DebugClear(context.Context, *DebugClearRequest) (*DebugClearResponse, error)
	mustEmbedUnimplementedControlServer()
}

// UnimplementedControlServer 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 UnimplementedControlServer struct{}

func (UnimplementedControlServer) GetActor(context.Context, *GetActorRequest) (*GetActorResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetActor not implemented")
}
func (UnimplementedControlServer) CreateActor(context.Context, *CreateActorRequest) (*CreateActorResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateActor not implemented")
}
func (UnimplementedControlServer) SuspendActor(context.Context, *SuspendActorRequest) (*SuspendActorResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SuspendActor not implemented")
}
func (UnimplementedControlServer) ResumeActor(context.Context, *ResumeActorRequest) (*ResumeActorResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ResumeActor not implemented")
}
func (UnimplementedControlServer) DeleteActor(context.Context, *DeleteActorRequest) (*DeleteActorResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteActor not implemented")
}
func (UnimplementedControlServer) ListWorkers(context.Context, *ListWorkersRequest) (*ListWorkersResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListWorkers not implemented")
}
func (UnimplementedControlServer) ListActors(context.Context, *ListActorsRequest) (*ListActorsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListActors not implemented")
}
func (UnimplementedControlServer) DebugClear(context.Context, *DebugClearRequest) (*DebugClearResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DebugClear not implemented")
}
func (UnimplementedControlServer) mustEmbedUnimplementedControlServer() {}
func (UnimplementedControlServer) testEmbeddedByValue()                 {}

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

func RegisterControlServer(s grpc.ServiceRegistrar, srv ControlServer) {
	// If the following call panics, it indicates UnimplementedControlServer 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(&Control_ServiceDesc, srv)
}

func _Control_GetActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetActorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).GetActor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_GetActor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).GetActor(ctx, req.(*GetActorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_CreateActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateActorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).CreateActor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_CreateActor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).CreateActor(ctx, req.(*CreateActorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_SuspendActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SuspendActorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).SuspendActor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_SuspendActor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).SuspendActor(ctx, req.(*SuspendActorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_ResumeActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResumeActorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).ResumeActor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_ResumeActor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).ResumeActor(ctx, req.(*ResumeActorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_DeleteActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteActorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).DeleteActor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_DeleteActor_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).DeleteActor(ctx, req.(*DeleteActorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_ListWorkers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWorkersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).ListWorkers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_ListWorkers_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).ListWorkers(ctx, req.(*ListWorkersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_ListActors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListActorsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).ListActors(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_ListActors_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).ListActors(ctx, req.(*ListActorsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_DebugClear_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DebugClearRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).DebugClear(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_DebugClear_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).DebugClear(ctx, req.(*DebugClearRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Control_ServiceDesc is the grpc.ServiceDesc for Control service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Control_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "ateapi.Control",
	HandlerType: (*ControlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetActor",
			Handler:    _Control_GetActor_Handler,
		},
		{
			MethodName: "CreateActor",
			Handler:    _Control_CreateActor_Handler,
		},
		{
			MethodName: "SuspendActor",
			Handler:    _Control_SuspendActor_Handler,
		},
		{
			MethodName: "ResumeActor",
			Handler:    _Control_ResumeActor_Handler,
		},
		{
			MethodName: "DeleteActor",
			Handler:    _Control_DeleteActor_Handler,
		},
		{
			MethodName: "ListWorkers",
			Handler:    _Control_ListWorkers_Handler,
		},
		{
			MethodName: "ListActors",
			Handler:    _Control_ListActors_Handler,
		},
		{
			MethodName: "DebugClear",
			Handler:    _Control_DebugClear_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "ateapi.proto",
}

const (
	SessionIdentity_MintJWT_FullMethodName  = "/ateapi.SessionIdentity/MintJWT"
	SessionIdentity_MintCert_FullMethodName = "/ateapi.SessionIdentity/MintCert"
)

// SessionIdentityClient is the client API for SessionIdentity 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.
//
// SessionIdentity allows substrate workloads to exchange their
// infrastructure-level credentials (k8s service account token, etc.) for a
// substrate session-level credential.  A given substrate session might migrate
// between many different physical workers over the course of its lifecycle,
// whereas the session credential's identity will be stable for the life of the
// session.
//
// This service requires authentication. You can authenticate with a Kubernetes
// service account token in an `Authorization: Bearer` header, or you can
// authenticate with a Kubernetes service account certificate as an mTLS
// certificate. (Kubernetes service account certificates do not currently exist
// upstream, but we will provide a polyfill based on Pod Certificates).
//
// The broker will check that the service credentials you authenticated with
// belong to a Pod that is currently mapped to the requested session in the
// session database.
type SessionIdentityClient interface {
	// Request a Session Identity JWT.
	//
	// To call this RPC, you must be authenticated as the Kubernetes Pod that is
	// currently running the requested session.
	MintJWT(ctx context.Context, in *MintJWTRequest, opts ...grpc.CallOption) (*MintJWTResponse, error)
	// Request a Session Identity Certificate. To call this RPC, you must have
	// authenticated with a client certificate, not a bearer token.
	MintCert(ctx context.Context, in *MintCertRequest, opts ...grpc.CallOption) (*MintCertResponse, error)
}

type sessionIdentityClient struct {
	cc grpc.ClientConnInterface
}

func NewSessionIdentityClient(cc grpc.ClientConnInterface) SessionIdentityClient {
	return &sessionIdentityClient{cc}
}

func (c *sessionIdentityClient) MintJWT(ctx context.Context, in *MintJWTRequest, opts ...grpc.CallOption) (*MintJWTResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MintJWTResponse)
	err := c.cc.Invoke(ctx, SessionIdentity_MintJWT_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sessionIdentityClient) MintCert(ctx context.Context, in *MintCertRequest, opts ...grpc.CallOption) (*MintCertResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MintCertResponse)
	err := c.cc.Invoke(ctx, SessionIdentity_MintCert_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SessionIdentityServer is the server API for SessionIdentity service.
// All implementations must embed UnimplementedSessionIdentityServer
// for forward compatibility.
//
// SessionIdentity allows substrate workloads to exchange their
// infrastructure-level credentials (k8s service account token, etc.) for a
// substrate session-level credential.  A given substrate session might migrate
// between many different physical workers over the course of its lifecycle,
// whereas the session credential's identity will be stable for the life of the
// session.
//
// This service requires authentication. You can authenticate with a Kubernetes
// service account token in an `Authorization: Bearer` header, or you can
// authenticate with a Kubernetes service account certificate as an mTLS
// certificate. (Kubernetes service account certificates do not currently exist
// upstream, but we will provide a polyfill based on Pod Certificates).
//
// The broker will check that the service credentials you authenticated with
// belong to a Pod that is currently mapped to the requested session in the
// session database.
type SessionIdentityServer interface {
	// Request a Session Identity JWT.
	//
	// To call this RPC, you must be authenticated as the Kubernetes Pod that is
	// currently running the requested session.
	MintJWT(context.Context, *MintJWTRequest) (*MintJWTResponse, error)
	// Request a Session Identity Certificate. To call this RPC, you must have
	// authenticated with a client certificate, not a bearer token.
	MintCert(context.Context, *MintCertRequest) (*MintCertResponse, error)
	mustEmbedUnimplementedSessionIdentityServer()
}

// UnimplementedSessionIdentityServer 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 UnimplementedSessionIdentityServer struct{}

func (UnimplementedSessionIdentityServer) MintJWT(context.Context, *MintJWTRequest) (*MintJWTResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method MintJWT not implemented")
}
func (UnimplementedSessionIdentityServer) MintCert(context.Context, *MintCertRequest) (*MintCertResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method MintCert not implemented")
}
func (UnimplementedSessionIdentityServer) mustEmbedUnimplementedSessionIdentityServer() {}
func (UnimplementedSessionIdentityServer) testEmbeddedByValue()                         {}

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

func RegisterSessionIdentityServer(s grpc.ServiceRegistrar, srv SessionIdentityServer) {
	// If the following call panics, it indicates UnimplementedSessionIdentityServer 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(&SessionIdentity_ServiceDesc, srv)
}

func _SessionIdentity_MintJWT_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MintJWTRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionIdentityServer).MintJWT(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SessionIdentity_MintJWT_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionIdentityServer).MintJWT(ctx, req.(*MintJWTRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SessionIdentity_MintCert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MintCertRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionIdentityServer).MintCert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SessionIdentity_MintCert_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionIdentityServer).MintCert(ctx, req.(*MintCertRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SessionIdentity_ServiceDesc is the grpc.ServiceDesc for SessionIdentity service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SessionIdentity_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "ateapi.SessionIdentity",
	HandlerType: (*SessionIdentityServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "MintJWT",
			Handler:    _SessionIdentity_MintJWT_Handler,
		},
		{
			MethodName: "MintCert",
			Handler:    _SessionIdentity_MintCert_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "ateapi.proto",
}
