// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             (unknown)
// source: v1beta1/service.proto

package adminapi

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// 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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// DataAppsServiceClient is the client API for DataAppsService 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 DataAppsServiceClient interface {
	// Create a new DataApp
	CreateDataApp(ctx context.Context, in *CreateDataAppRequest, opts ...grpc.CallOption) (*DataApp, error)
	// Get a DataApp
	GetDataApp(ctx context.Context, in *GetDataAppRequest, opts ...grpc.CallOption) (*DataApp, error)
	// List DataApps
	ListDataApps(ctx context.Context, in *ListDataAppsRequest, opts ...grpc.CallOption) (*ListDataAppsResponse, error)
	// Update a DataApp
	UpdateDataApp(ctx context.Context, in *UpdateDataAppRequest, opts ...grpc.CallOption) (*DataApp, error)
	// Delete a DataApp
	DeleteDataApp(ctx context.Context, in *DeleteDataAppRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Get Chat2Query Settings
	GetChat2QuerySettings(ctx context.Context, in *GetChat2QuerySettingsRequest, opts ...grpc.CallOption) (*Chat2QuerySettings, error)
	// Update Chat2Query Settings
	UpdateChat2QuerySettings(ctx context.Context, in *UpdateChat2QuerySettingsRequest, opts ...grpc.CallOption) (*Chat2QuerySettings, error)
	// Get System Endpoint Config
	GetSystemEndpointConfig(ctx context.Context, in *GetSystemEndpointConfigRequest, opts ...grpc.CallOption) (*SystemEndpointConfig, error)
	// Update System Endpoint Config
	UpdateSystemEndpointConfig(ctx context.Context, in *UpdateSystemEndpointConfigRequest, opts ...grpc.CallOption) (*SystemEndpointConfig, error)
}

type dataAppsServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDataAppsServiceClient(cc grpc.ClientConnInterface) DataAppsServiceClient {
	return &dataAppsServiceClient{cc}
}

func (c *dataAppsServiceClient) CreateDataApp(ctx context.Context, in *CreateDataAppRequest, opts ...grpc.CallOption) (*DataApp, error) {
	out := new(DataApp)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/CreateDataApp", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataAppsServiceClient) GetDataApp(ctx context.Context, in *GetDataAppRequest, opts ...grpc.CallOption) (*DataApp, error) {
	out := new(DataApp)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/GetDataApp", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataAppsServiceClient) ListDataApps(ctx context.Context, in *ListDataAppsRequest, opts ...grpc.CallOption) (*ListDataAppsResponse, error) {
	out := new(ListDataAppsResponse)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/ListDataApps", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataAppsServiceClient) UpdateDataApp(ctx context.Context, in *UpdateDataAppRequest, opts ...grpc.CallOption) (*DataApp, error) {
	out := new(DataApp)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/UpdateDataApp", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataAppsServiceClient) DeleteDataApp(ctx context.Context, in *DeleteDataAppRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/DeleteDataApp", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataAppsServiceClient) GetChat2QuerySettings(ctx context.Context, in *GetChat2QuerySettingsRequest, opts ...grpc.CallOption) (*Chat2QuerySettings, error) {
	out := new(Chat2QuerySettings)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/GetChat2QuerySettings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataAppsServiceClient) UpdateChat2QuerySettings(ctx context.Context, in *UpdateChat2QuerySettingsRequest, opts ...grpc.CallOption) (*Chat2QuerySettings, error) {
	out := new(Chat2QuerySettings)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/UpdateChat2QuerySettings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataAppsServiceClient) GetSystemEndpointConfig(ctx context.Context, in *GetSystemEndpointConfigRequest, opts ...grpc.CallOption) (*SystemEndpointConfig, error) {
	out := new(SystemEndpointConfig)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/GetSystemEndpointConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataAppsServiceClient) UpdateSystemEndpointConfig(ctx context.Context, in *UpdateSystemEndpointConfigRequest, opts ...grpc.CallOption) (*SystemEndpointConfig, error) {
	out := new(SystemEndpointConfig)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataAppsService/UpdateSystemEndpointConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DataAppsServiceServer is the server API for DataAppsService service.
// All implementations must embed UnimplementedDataAppsServiceServer
// for forward compatibility
type DataAppsServiceServer interface {
	// Create a new DataApp
	CreateDataApp(context.Context, *CreateDataAppRequest) (*DataApp, error)
	// Get a DataApp
	GetDataApp(context.Context, *GetDataAppRequest) (*DataApp, error)
	// List DataApps
	ListDataApps(context.Context, *ListDataAppsRequest) (*ListDataAppsResponse, error)
	// Update a DataApp
	UpdateDataApp(context.Context, *UpdateDataAppRequest) (*DataApp, error)
	// Delete a DataApp
	DeleteDataApp(context.Context, *DeleteDataAppRequest) (*emptypb.Empty, error)
	// Get Chat2Query Settings
	GetChat2QuerySettings(context.Context, *GetChat2QuerySettingsRequest) (*Chat2QuerySettings, error)
	// Update Chat2Query Settings
	UpdateChat2QuerySettings(context.Context, *UpdateChat2QuerySettingsRequest) (*Chat2QuerySettings, error)
	// Get System Endpoint Config
	GetSystemEndpointConfig(context.Context, *GetSystemEndpointConfigRequest) (*SystemEndpointConfig, error)
	// Update System Endpoint Config
	UpdateSystemEndpointConfig(context.Context, *UpdateSystemEndpointConfigRequest) (*SystemEndpointConfig, error)
	mustEmbedUnimplementedDataAppsServiceServer()
}

// UnimplementedDataAppsServiceServer must be embedded to have forward compatible implementations.
type UnimplementedDataAppsServiceServer struct {
}

func (UnimplementedDataAppsServiceServer) CreateDataApp(context.Context, *CreateDataAppRequest) (*DataApp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateDataApp not implemented")
}
func (UnimplementedDataAppsServiceServer) GetDataApp(context.Context, *GetDataAppRequest) (*DataApp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataApp not implemented")
}
func (UnimplementedDataAppsServiceServer) ListDataApps(context.Context, *ListDataAppsRequest) (*ListDataAppsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListDataApps not implemented")
}
func (UnimplementedDataAppsServiceServer) UpdateDataApp(context.Context, *UpdateDataAppRequest) (*DataApp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateDataApp not implemented")
}
func (UnimplementedDataAppsServiceServer) DeleteDataApp(context.Context, *DeleteDataAppRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDataApp not implemented")
}
func (UnimplementedDataAppsServiceServer) GetChat2QuerySettings(context.Context, *GetChat2QuerySettingsRequest) (*Chat2QuerySettings, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetChat2QuerySettings not implemented")
}
func (UnimplementedDataAppsServiceServer) UpdateChat2QuerySettings(context.Context, *UpdateChat2QuerySettingsRequest) (*Chat2QuerySettings, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateChat2QuerySettings not implemented")
}
func (UnimplementedDataAppsServiceServer) GetSystemEndpointConfig(context.Context, *GetSystemEndpointConfigRequest) (*SystemEndpointConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSystemEndpointConfig not implemented")
}
func (UnimplementedDataAppsServiceServer) UpdateSystemEndpointConfig(context.Context, *UpdateSystemEndpointConfigRequest) (*SystemEndpointConfig, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSystemEndpointConfig not implemented")
}
func (UnimplementedDataAppsServiceServer) mustEmbedUnimplementedDataAppsServiceServer() {}

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

func RegisterDataAppsServiceServer(s grpc.ServiceRegistrar, srv DataAppsServiceServer) {
	s.RegisterService(&DataAppsService_ServiceDesc, srv)
}

func _DataAppsService_CreateDataApp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateDataAppRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).CreateDataApp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/CreateDataApp",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).CreateDataApp(ctx, req.(*CreateDataAppRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataAppsService_GetDataApp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDataAppRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).GetDataApp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/GetDataApp",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).GetDataApp(ctx, req.(*GetDataAppRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataAppsService_ListDataApps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDataAppsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).ListDataApps(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/ListDataApps",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).ListDataApps(ctx, req.(*ListDataAppsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataAppsService_UpdateDataApp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateDataAppRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).UpdateDataApp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/UpdateDataApp",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).UpdateDataApp(ctx, req.(*UpdateDataAppRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataAppsService_DeleteDataApp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteDataAppRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).DeleteDataApp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/DeleteDataApp",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).DeleteDataApp(ctx, req.(*DeleteDataAppRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataAppsService_GetChat2QuerySettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetChat2QuerySettingsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).GetChat2QuerySettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/GetChat2QuerySettings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).GetChat2QuerySettings(ctx, req.(*GetChat2QuerySettingsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataAppsService_UpdateChat2QuerySettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateChat2QuerySettingsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).UpdateChat2QuerySettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/UpdateChat2QuerySettings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).UpdateChat2QuerySettings(ctx, req.(*UpdateChat2QuerySettingsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataAppsService_GetSystemEndpointConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSystemEndpointConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).GetSystemEndpointConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/GetSystemEndpointConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).GetSystemEndpointConfig(ctx, req.(*GetSystemEndpointConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataAppsService_UpdateSystemEndpointConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSystemEndpointConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataAppsServiceServer).UpdateSystemEndpointConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataAppsService/UpdateSystemEndpointConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataAppsServiceServer).UpdateSystemEndpointConfig(ctx, req.(*UpdateSystemEndpointConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DataAppsService_ServiceDesc is the grpc.ServiceDesc for DataAppsService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DataAppsService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "adminapi.v1beta1.DataAppsService",
	HandlerType: (*DataAppsServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateDataApp",
			Handler:    _DataAppsService_CreateDataApp_Handler,
		},
		{
			MethodName: "GetDataApp",
			Handler:    _DataAppsService_GetDataApp_Handler,
		},
		{
			MethodName: "ListDataApps",
			Handler:    _DataAppsService_ListDataApps_Handler,
		},
		{
			MethodName: "UpdateDataApp",
			Handler:    _DataAppsService_UpdateDataApp_Handler,
		},
		{
			MethodName: "DeleteDataApp",
			Handler:    _DataAppsService_DeleteDataApp_Handler,
		},
		{
			MethodName: "GetChat2QuerySettings",
			Handler:    _DataAppsService_GetChat2QuerySettings_Handler,
		},
		{
			MethodName: "UpdateChat2QuerySettings",
			Handler:    _DataAppsService_UpdateChat2QuerySettings_Handler,
		},
		{
			MethodName: "GetSystemEndpointConfig",
			Handler:    _DataAppsService_GetSystemEndpointConfig_Handler,
		},
		{
			MethodName: "UpdateSystemEndpointConfig",
			Handler:    _DataAppsService_UpdateSystemEndpointConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "v1beta1/service.proto",
}

// DataSourcesServiceClient is the client API for DataSourcesService 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 DataSourcesServiceClient interface {
	// Create a new DataSource
	CreateDataSource(ctx context.Context, in *CreateDataSourceRequest, opts ...grpc.CallOption) (*DataSource, error)
	// Get a DataSource
	GetDataSource(ctx context.Context, in *GetDataSourceRequest, opts ...grpc.CallOption) (*DataSource, error)
	// List DataSources
	ListDataSources(ctx context.Context, in *ListDataSourcesRequest, opts ...grpc.CallOption) (*ListDataSourcesResponse, error)
	// Delete a DataSource
	DeleteDataSource(ctx context.Context, in *DeleteDataSourceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type dataSourcesServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDataSourcesServiceClient(cc grpc.ClientConnInterface) DataSourcesServiceClient {
	return &dataSourcesServiceClient{cc}
}

func (c *dataSourcesServiceClient) CreateDataSource(ctx context.Context, in *CreateDataSourceRequest, opts ...grpc.CallOption) (*DataSource, error) {
	out := new(DataSource)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataSourcesService/CreateDataSource", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataSourcesServiceClient) GetDataSource(ctx context.Context, in *GetDataSourceRequest, opts ...grpc.CallOption) (*DataSource, error) {
	out := new(DataSource)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataSourcesService/GetDataSource", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataSourcesServiceClient) ListDataSources(ctx context.Context, in *ListDataSourcesRequest, opts ...grpc.CallOption) (*ListDataSourcesResponse, error) {
	out := new(ListDataSourcesResponse)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataSourcesService/ListDataSources", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataSourcesServiceClient) DeleteDataSource(ctx context.Context, in *DeleteDataSourceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DataSourcesService/DeleteDataSource", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DataSourcesServiceServer is the server API for DataSourcesService service.
// All implementations must embed UnimplementedDataSourcesServiceServer
// for forward compatibility
type DataSourcesServiceServer interface {
	// Create a new DataSource
	CreateDataSource(context.Context, *CreateDataSourceRequest) (*DataSource, error)
	// Get a DataSource
	GetDataSource(context.Context, *GetDataSourceRequest) (*DataSource, error)
	// List DataSources
	ListDataSources(context.Context, *ListDataSourcesRequest) (*ListDataSourcesResponse, error)
	// Delete a DataSource
	DeleteDataSource(context.Context, *DeleteDataSourceRequest) (*emptypb.Empty, error)
	mustEmbedUnimplementedDataSourcesServiceServer()
}

// UnimplementedDataSourcesServiceServer must be embedded to have forward compatible implementations.
type UnimplementedDataSourcesServiceServer struct {
}

func (UnimplementedDataSourcesServiceServer) CreateDataSource(context.Context, *CreateDataSourceRequest) (*DataSource, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateDataSource not implemented")
}
func (UnimplementedDataSourcesServiceServer) GetDataSource(context.Context, *GetDataSourceRequest) (*DataSource, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataSource not implemented")
}
func (UnimplementedDataSourcesServiceServer) ListDataSources(context.Context, *ListDataSourcesRequest) (*ListDataSourcesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListDataSources not implemented")
}
func (UnimplementedDataSourcesServiceServer) DeleteDataSource(context.Context, *DeleteDataSourceRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDataSource not implemented")
}
func (UnimplementedDataSourcesServiceServer) mustEmbedUnimplementedDataSourcesServiceServer() {}

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

func RegisterDataSourcesServiceServer(s grpc.ServiceRegistrar, srv DataSourcesServiceServer) {
	s.RegisterService(&DataSourcesService_ServiceDesc, srv)
}

func _DataSourcesService_CreateDataSource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateDataSourceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataSourcesServiceServer).CreateDataSource(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataSourcesService/CreateDataSource",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataSourcesServiceServer).CreateDataSource(ctx, req.(*CreateDataSourceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataSourcesService_GetDataSource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDataSourceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataSourcesServiceServer).GetDataSource(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataSourcesService/GetDataSource",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataSourcesServiceServer).GetDataSource(ctx, req.(*GetDataSourceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataSourcesService_ListDataSources_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDataSourcesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataSourcesServiceServer).ListDataSources(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataSourcesService/ListDataSources",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataSourcesServiceServer).ListDataSources(ctx, req.(*ListDataSourcesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataSourcesService_DeleteDataSource_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteDataSourceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataSourcesServiceServer).DeleteDataSource(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DataSourcesService/DeleteDataSource",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataSourcesServiceServer).DeleteDataSource(ctx, req.(*DeleteDataSourceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DataSourcesService_ServiceDesc is the grpc.ServiceDesc for DataSourcesService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DataSourcesService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "adminapi.v1beta1.DataSourcesService",
	HandlerType: (*DataSourcesServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateDataSource",
			Handler:    _DataSourcesService_CreateDataSource_Handler,
		},
		{
			MethodName: "GetDataSource",
			Handler:    _DataSourcesService_GetDataSource_Handler,
		},
		{
			MethodName: "ListDataSources",
			Handler:    _DataSourcesService_ListDataSources_Handler,
		},
		{
			MethodName: "DeleteDataSource",
			Handler:    _DataSourcesService_DeleteDataSource_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "v1beta1/service.proto",
}

// EndpointsServiceClient is the client API for EndpointsService 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 EndpointsServiceClient interface {
	// Create a new Endpoint
	CreateEndpoint(ctx context.Context, in *CreateEndpointRequest, opts ...grpc.CallOption) (*Endpoint, error)
	// Get an Endpoint
	GetEndpoint(ctx context.Context, in *GetEndpointRequest, opts ...grpc.CallOption) (*Endpoint, error)
	// List Endpoints
	ListEndpoints(ctx context.Context, in *ListEndpointsRequest, opts ...grpc.CallOption) (*ListEndpointsResponse, error)
	// Update an Endpoint
	UpdateEndpoint(ctx context.Context, in *UpdateEndpointRequest, opts ...grpc.CallOption) (*Endpoint, error)
	// Delete an Endpoint
	DeleteEndpoint(ctx context.Context, in *DeleteEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Test an Endpoint
	TestEndpoint(ctx context.Context, in *TestEndpointRequest, opts ...grpc.CallOption) (*TestEndpointResponse, error)
}

type endpointsServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewEndpointsServiceClient(cc grpc.ClientConnInterface) EndpointsServiceClient {
	return &endpointsServiceClient{cc}
}

func (c *endpointsServiceClient) CreateEndpoint(ctx context.Context, in *CreateEndpointRequest, opts ...grpc.CallOption) (*Endpoint, error) {
	out := new(Endpoint)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.EndpointsService/CreateEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *endpointsServiceClient) GetEndpoint(ctx context.Context, in *GetEndpointRequest, opts ...grpc.CallOption) (*Endpoint, error) {
	out := new(Endpoint)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.EndpointsService/GetEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *endpointsServiceClient) ListEndpoints(ctx context.Context, in *ListEndpointsRequest, opts ...grpc.CallOption) (*ListEndpointsResponse, error) {
	out := new(ListEndpointsResponse)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.EndpointsService/ListEndpoints", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *endpointsServiceClient) UpdateEndpoint(ctx context.Context, in *UpdateEndpointRequest, opts ...grpc.CallOption) (*Endpoint, error) {
	out := new(Endpoint)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.EndpointsService/UpdateEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *endpointsServiceClient) DeleteEndpoint(ctx context.Context, in *DeleteEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.EndpointsService/DeleteEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *endpointsServiceClient) TestEndpoint(ctx context.Context, in *TestEndpointRequest, opts ...grpc.CallOption) (*TestEndpointResponse, error) {
	out := new(TestEndpointResponse)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.EndpointsService/TestEndpoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// EndpointsServiceServer is the server API for EndpointsService service.
// All implementations must embed UnimplementedEndpointsServiceServer
// for forward compatibility
type EndpointsServiceServer interface {
	// Create a new Endpoint
	CreateEndpoint(context.Context, *CreateEndpointRequest) (*Endpoint, error)
	// Get an Endpoint
	GetEndpoint(context.Context, *GetEndpointRequest) (*Endpoint, error)
	// List Endpoints
	ListEndpoints(context.Context, *ListEndpointsRequest) (*ListEndpointsResponse, error)
	// Update an Endpoint
	UpdateEndpoint(context.Context, *UpdateEndpointRequest) (*Endpoint, error)
	// Delete an Endpoint
	DeleteEndpoint(context.Context, *DeleteEndpointRequest) (*emptypb.Empty, error)
	// Test an Endpoint
	TestEndpoint(context.Context, *TestEndpointRequest) (*TestEndpointResponse, error)
	mustEmbedUnimplementedEndpointsServiceServer()
}

// UnimplementedEndpointsServiceServer must be embedded to have forward compatible implementations.
type UnimplementedEndpointsServiceServer struct {
}

func (UnimplementedEndpointsServiceServer) CreateEndpoint(context.Context, *CreateEndpointRequest) (*Endpoint, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateEndpoint not implemented")
}
func (UnimplementedEndpointsServiceServer) GetEndpoint(context.Context, *GetEndpointRequest) (*Endpoint, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEndpoint not implemented")
}
func (UnimplementedEndpointsServiceServer) ListEndpoints(context.Context, *ListEndpointsRequest) (*ListEndpointsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListEndpoints not implemented")
}
func (UnimplementedEndpointsServiceServer) UpdateEndpoint(context.Context, *UpdateEndpointRequest) (*Endpoint, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateEndpoint not implemented")
}
func (UnimplementedEndpointsServiceServer) DeleteEndpoint(context.Context, *DeleteEndpointRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteEndpoint not implemented")
}
func (UnimplementedEndpointsServiceServer) TestEndpoint(context.Context, *TestEndpointRequest) (*TestEndpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestEndpoint not implemented")
}
func (UnimplementedEndpointsServiceServer) mustEmbedUnimplementedEndpointsServiceServer() {}

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

func RegisterEndpointsServiceServer(s grpc.ServiceRegistrar, srv EndpointsServiceServer) {
	s.RegisterService(&EndpointsService_ServiceDesc, srv)
}

func _EndpointsService_CreateEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EndpointsServiceServer).CreateEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.EndpointsService/CreateEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EndpointsServiceServer).CreateEndpoint(ctx, req.(*CreateEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EndpointsService_GetEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EndpointsServiceServer).GetEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.EndpointsService/GetEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EndpointsServiceServer).GetEndpoint(ctx, req.(*GetEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EndpointsService_ListEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListEndpointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EndpointsServiceServer).ListEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.EndpointsService/ListEndpoints",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EndpointsServiceServer).ListEndpoints(ctx, req.(*ListEndpointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EndpointsService_UpdateEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EndpointsServiceServer).UpdateEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.EndpointsService/UpdateEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EndpointsServiceServer).UpdateEndpoint(ctx, req.(*UpdateEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EndpointsService_DeleteEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EndpointsServiceServer).DeleteEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.EndpointsService/DeleteEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EndpointsServiceServer).DeleteEndpoint(ctx, req.(*DeleteEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EndpointsService_TestEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EndpointsServiceServer).TestEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.EndpointsService/TestEndpoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EndpointsServiceServer).TestEndpoint(ctx, req.(*TestEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// EndpointsService_ServiceDesc is the grpc.ServiceDesc for EndpointsService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var EndpointsService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "adminapi.v1beta1.EndpointsService",
	HandlerType: (*EndpointsServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateEndpoint",
			Handler:    _EndpointsService_CreateEndpoint_Handler,
		},
		{
			MethodName: "GetEndpoint",
			Handler:    _EndpointsService_GetEndpoint_Handler,
		},
		{
			MethodName: "ListEndpoints",
			Handler:    _EndpointsService_ListEndpoints_Handler,
		},
		{
			MethodName: "UpdateEndpoint",
			Handler:    _EndpointsService_UpdateEndpoint_Handler,
		},
		{
			MethodName: "DeleteEndpoint",
			Handler:    _EndpointsService_DeleteEndpoint_Handler,
		},
		{
			MethodName: "TestEndpoint",
			Handler:    _EndpointsService_TestEndpoint_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "v1beta1/service.proto",
}

// DeploymentsServiceClient is the client API for DeploymentsService 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 DeploymentsServiceClient interface {
	// Create a new Deployment
	CreateDeployment(ctx context.Context, in *CreateDeploymentRequest, opts ...grpc.CallOption) (*Deployment, error)
	// List Deployments
	ListDeployments(ctx context.Context, in *ListDeploymentsRequest, opts ...grpc.CallOption) (*ListDeploymentsResponse, error)
	// Get Deployments by id
	GetDeployment(ctx context.Context, in *GetDeploymentRequest, opts ...grpc.CallOption) (*Deployment, error)
}

type deploymentsServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDeploymentsServiceClient(cc grpc.ClientConnInterface) DeploymentsServiceClient {
	return &deploymentsServiceClient{cc}
}

func (c *deploymentsServiceClient) CreateDeployment(ctx context.Context, in *CreateDeploymentRequest, opts ...grpc.CallOption) (*Deployment, error) {
	out := new(Deployment)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DeploymentsService/CreateDeployment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deploymentsServiceClient) ListDeployments(ctx context.Context, in *ListDeploymentsRequest, opts ...grpc.CallOption) (*ListDeploymentsResponse, error) {
	out := new(ListDeploymentsResponse)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DeploymentsService/ListDeployments", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *deploymentsServiceClient) GetDeployment(ctx context.Context, in *GetDeploymentRequest, opts ...grpc.CallOption) (*Deployment, error) {
	out := new(Deployment)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.DeploymentsService/GetDeployment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DeploymentsServiceServer is the server API for DeploymentsService service.
// All implementations must embed UnimplementedDeploymentsServiceServer
// for forward compatibility
type DeploymentsServiceServer interface {
	// Create a new Deployment
	CreateDeployment(context.Context, *CreateDeploymentRequest) (*Deployment, error)
	// List Deployments
	ListDeployments(context.Context, *ListDeploymentsRequest) (*ListDeploymentsResponse, error)
	// Get Deployments by id
	GetDeployment(context.Context, *GetDeploymentRequest) (*Deployment, error)
	mustEmbedUnimplementedDeploymentsServiceServer()
}

// UnimplementedDeploymentsServiceServer must be embedded to have forward compatible implementations.
type UnimplementedDeploymentsServiceServer struct {
}

func (UnimplementedDeploymentsServiceServer) CreateDeployment(context.Context, *CreateDeploymentRequest) (*Deployment, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateDeployment not implemented")
}
func (UnimplementedDeploymentsServiceServer) ListDeployments(context.Context, *ListDeploymentsRequest) (*ListDeploymentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListDeployments not implemented")
}
func (UnimplementedDeploymentsServiceServer) GetDeployment(context.Context, *GetDeploymentRequest) (*Deployment, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDeployment not implemented")
}
func (UnimplementedDeploymentsServiceServer) mustEmbedUnimplementedDeploymentsServiceServer() {}

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

func RegisterDeploymentsServiceServer(s grpc.ServiceRegistrar, srv DeploymentsServiceServer) {
	s.RegisterService(&DeploymentsService_ServiceDesc, srv)
}

func _DeploymentsService_CreateDeployment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateDeploymentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeploymentsServiceServer).CreateDeployment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DeploymentsService/CreateDeployment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeploymentsServiceServer).CreateDeployment(ctx, req.(*CreateDeploymentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeploymentsService_ListDeployments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDeploymentsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeploymentsServiceServer).ListDeployments(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DeploymentsService/ListDeployments",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeploymentsServiceServer).ListDeployments(ctx, req.(*ListDeploymentsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DeploymentsService_GetDeployment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDeploymentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DeploymentsServiceServer).GetDeployment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.DeploymentsService/GetDeployment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DeploymentsServiceServer).GetDeployment(ctx, req.(*GetDeploymentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DeploymentsService_ServiceDesc is the grpc.ServiceDesc for DeploymentsService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DeploymentsService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "adminapi.v1beta1.DeploymentsService",
	HandlerType: (*DeploymentsServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateDeployment",
			Handler:    _DeploymentsService_CreateDeployment_Handler,
		},
		{
			MethodName: "ListDeployments",
			Handler:    _DeploymentsService_ListDeployments_Handler,
		},
		{
			MethodName: "GetDeployment",
			Handler:    _DeploymentsService_GetDeployment_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "v1beta1/service.proto",
}

// ApiKeyServiceClient is the client API for ApiKeyService 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 ApiKeyServiceClient interface {
	// Create a new API key
	CreateApiKey(ctx context.Context, in *CreateApiKeyRequest, opts ...grpc.CallOption) (*ApiKey, error)
	// Get an API key
	GetApiKey(ctx context.Context, in *GetApiKeyRequest, opts ...grpc.CallOption) (*ApiKey, error)
	// List API keys
	ListApiKeys(ctx context.Context, in *ListApiKeysRequest, opts ...grpc.CallOption) (*ListApiKeysResponse, error)
	// Update an API key
	UpdateApiKey(ctx context.Context, in *UpdateApiKeyRequest, opts ...grpc.CallOption) (*ApiKey, error)
	// Delete an API key
	DeleteApiKey(ctx context.Context, in *DeleteApiKeyRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type apiKeyServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewApiKeyServiceClient(cc grpc.ClientConnInterface) ApiKeyServiceClient {
	return &apiKeyServiceClient{cc}
}

func (c *apiKeyServiceClient) CreateApiKey(ctx context.Context, in *CreateApiKeyRequest, opts ...grpc.CallOption) (*ApiKey, error) {
	out := new(ApiKey)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.ApiKeyService/CreateApiKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiKeyServiceClient) GetApiKey(ctx context.Context, in *GetApiKeyRequest, opts ...grpc.CallOption) (*ApiKey, error) {
	out := new(ApiKey)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.ApiKeyService/GetApiKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiKeyServiceClient) ListApiKeys(ctx context.Context, in *ListApiKeysRequest, opts ...grpc.CallOption) (*ListApiKeysResponse, error) {
	out := new(ListApiKeysResponse)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.ApiKeyService/ListApiKeys", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiKeyServiceClient) UpdateApiKey(ctx context.Context, in *UpdateApiKeyRequest, opts ...grpc.CallOption) (*ApiKey, error) {
	out := new(ApiKey)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.ApiKeyService/UpdateApiKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiKeyServiceClient) DeleteApiKey(ctx context.Context, in *DeleteApiKeyRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.ApiKeyService/DeleteApiKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ApiKeyServiceServer is the server API for ApiKeyService service.
// All implementations must embed UnimplementedApiKeyServiceServer
// for forward compatibility
type ApiKeyServiceServer interface {
	// Create a new API key
	CreateApiKey(context.Context, *CreateApiKeyRequest) (*ApiKey, error)
	// Get an API key
	GetApiKey(context.Context, *GetApiKeyRequest) (*ApiKey, error)
	// List API keys
	ListApiKeys(context.Context, *ListApiKeysRequest) (*ListApiKeysResponse, error)
	// Update an API key
	UpdateApiKey(context.Context, *UpdateApiKeyRequest) (*ApiKey, error)
	// Delete an API key
	DeleteApiKey(context.Context, *DeleteApiKeyRequest) (*emptypb.Empty, error)
	mustEmbedUnimplementedApiKeyServiceServer()
}

// UnimplementedApiKeyServiceServer must be embedded to have forward compatible implementations.
type UnimplementedApiKeyServiceServer struct {
}

func (UnimplementedApiKeyServiceServer) CreateApiKey(context.Context, *CreateApiKeyRequest) (*ApiKey, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateApiKey not implemented")
}
func (UnimplementedApiKeyServiceServer) GetApiKey(context.Context, *GetApiKeyRequest) (*ApiKey, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetApiKey not implemented")
}
func (UnimplementedApiKeyServiceServer) ListApiKeys(context.Context, *ListApiKeysRequest) (*ListApiKeysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListApiKeys not implemented")
}
func (UnimplementedApiKeyServiceServer) UpdateApiKey(context.Context, *UpdateApiKeyRequest) (*ApiKey, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateApiKey not implemented")
}
func (UnimplementedApiKeyServiceServer) DeleteApiKey(context.Context, *DeleteApiKeyRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteApiKey not implemented")
}
func (UnimplementedApiKeyServiceServer) mustEmbedUnimplementedApiKeyServiceServer() {}

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

func RegisterApiKeyServiceServer(s grpc.ServiceRegistrar, srv ApiKeyServiceServer) {
	s.RegisterService(&ApiKeyService_ServiceDesc, srv)
}

func _ApiKeyService_CreateApiKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateApiKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiKeyServiceServer).CreateApiKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.ApiKeyService/CreateApiKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiKeyServiceServer).CreateApiKey(ctx, req.(*CreateApiKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiKeyService_GetApiKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetApiKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiKeyServiceServer).GetApiKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.ApiKeyService/GetApiKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiKeyServiceServer).GetApiKey(ctx, req.(*GetApiKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiKeyService_ListApiKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListApiKeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiKeyServiceServer).ListApiKeys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.ApiKeyService/ListApiKeys",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiKeyServiceServer).ListApiKeys(ctx, req.(*ListApiKeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiKeyService_UpdateApiKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateApiKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiKeyServiceServer).UpdateApiKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.ApiKeyService/UpdateApiKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiKeyServiceServer).UpdateApiKey(ctx, req.(*UpdateApiKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiKeyService_DeleteApiKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteApiKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiKeyServiceServer).DeleteApiKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.ApiKeyService/DeleteApiKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiKeyServiceServer).DeleteApiKey(ctx, req.(*DeleteApiKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ApiKeyService_ServiceDesc is the grpc.ServiceDesc for ApiKeyService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ApiKeyService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "adminapi.v1beta1.ApiKeyService",
	HandlerType: (*ApiKeyServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateApiKey",
			Handler:    _ApiKeyService_CreateApiKey_Handler,
		},
		{
			MethodName: "GetApiKey",
			Handler:    _ApiKeyService_GetApiKey_Handler,
		},
		{
			MethodName: "ListApiKeys",
			Handler:    _ApiKeyService_ListApiKeys_Handler,
		},
		{
			MethodName: "UpdateApiKey",
			Handler:    _ApiKeyService_UpdateApiKey_Handler,
		},
		{
			MethodName: "DeleteApiKey",
			Handler:    _ApiKeyService_DeleteApiKey_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "v1beta1/service.proto",
}

// ApiSpecServiceClient is the client API for ApiSpecService 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 ApiSpecServiceClient interface {
	// Get API Specification of Data App
	GetApiSpec(ctx context.Context, in *GetApiSpecRequest, opts ...grpc.CallOption) (*ApiSpec, error)
}

type apiSpecServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewApiSpecServiceClient(cc grpc.ClientConnInterface) ApiSpecServiceClient {
	return &apiSpecServiceClient{cc}
}

func (c *apiSpecServiceClient) GetApiSpec(ctx context.Context, in *GetApiSpecRequest, opts ...grpc.CallOption) (*ApiSpec, error) {
	out := new(ApiSpec)
	err := c.cc.Invoke(ctx, "/adminapi.v1beta1.ApiSpecService/GetApiSpec", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ApiSpecServiceServer is the server API for ApiSpecService service.
// All implementations must embed UnimplementedApiSpecServiceServer
// for forward compatibility
type ApiSpecServiceServer interface {
	// Get API Specification of Data App
	GetApiSpec(context.Context, *GetApiSpecRequest) (*ApiSpec, error)
	mustEmbedUnimplementedApiSpecServiceServer()
}

// UnimplementedApiSpecServiceServer must be embedded to have forward compatible implementations.
type UnimplementedApiSpecServiceServer struct {
}

func (UnimplementedApiSpecServiceServer) GetApiSpec(context.Context, *GetApiSpecRequest) (*ApiSpec, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetApiSpec not implemented")
}
func (UnimplementedApiSpecServiceServer) mustEmbedUnimplementedApiSpecServiceServer() {}

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

func RegisterApiSpecServiceServer(s grpc.ServiceRegistrar, srv ApiSpecServiceServer) {
	s.RegisterService(&ApiSpecService_ServiceDesc, srv)
}

func _ApiSpecService_GetApiSpec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetApiSpecRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiSpecServiceServer).GetApiSpec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/adminapi.v1beta1.ApiSpecService/GetApiSpec",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiSpecServiceServer).GetApiSpec(ctx, req.(*GetApiSpecRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ApiSpecService_ServiceDesc is the grpc.ServiceDesc for ApiSpecService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ApiSpecService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "adminapi.v1beta1.ApiSpecService",
	HandlerType: (*ApiSpecServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetApiSpec",
			Handler:    _ApiSpecService_GetApiSpec_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "v1beta1/service.proto",
}