// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             v5.29.2
// source: avs.proto

package avsproto

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 (
	Aggregator_GetKey_FullMethodName             = "/aggregator.Aggregator/GetKey"
	Aggregator_GetSignatureFormat_FullMethodName = "/aggregator.Aggregator/GetSignatureFormat"
	Aggregator_GetNonce_FullMethodName           = "/aggregator.Aggregator/GetNonce"
	Aggregator_GetWallet_FullMethodName          = "/aggregator.Aggregator/GetWallet"
	Aggregator_SetWallet_FullMethodName          = "/aggregator.Aggregator/SetWallet"
	Aggregator_ListWallets_FullMethodName        = "/aggregator.Aggregator/ListWallets"
	Aggregator_WithdrawFunds_FullMethodName      = "/aggregator.Aggregator/WithdrawFunds"
	Aggregator_CreateTask_FullMethodName         = "/aggregator.Aggregator/CreateTask"
	Aggregator_ListTasks_FullMethodName          = "/aggregator.Aggregator/ListTasks"
	Aggregator_GetTask_FullMethodName            = "/aggregator.Aggregator/GetTask"
	Aggregator_ListExecutions_FullMethodName     = "/aggregator.Aggregator/ListExecutions"
	Aggregator_GetExecution_FullMethodName       = "/aggregator.Aggregator/GetExecution"
	Aggregator_GetExecutionStatus_FullMethodName = "/aggregator.Aggregator/GetExecutionStatus"
	Aggregator_CancelTask_FullMethodName         = "/aggregator.Aggregator/CancelTask"
	Aggregator_DeleteTask_FullMethodName         = "/aggregator.Aggregator/DeleteTask"
	Aggregator_TriggerTask_FullMethodName        = "/aggregator.Aggregator/TriggerTask"
	Aggregator_CreateSecret_FullMethodName       = "/aggregator.Aggregator/CreateSecret"
	Aggregator_DeleteSecret_FullMethodName       = "/aggregator.Aggregator/DeleteSecret"
	Aggregator_ListSecrets_FullMethodName        = "/aggregator.Aggregator/ListSecrets"
	Aggregator_UpdateSecret_FullMethodName       = "/aggregator.Aggregator/UpdateSecret"
	Aggregator_GetWorkflowCount_FullMethodName   = "/aggregator.Aggregator/GetWorkflowCount"
	Aggregator_GetExecutionCount_FullMethodName  = "/aggregator.Aggregator/GetExecutionCount"
	Aggregator_GetExecutionStats_FullMethodName  = "/aggregator.Aggregator/GetExecutionStats"
	Aggregator_RunNodeWithInputs_FullMethodName  = "/aggregator.Aggregator/RunNodeWithInputs"
	Aggregator_RunTrigger_FullMethodName         = "/aggregator.Aggregator/RunTrigger"
	Aggregator_SimulateTask_FullMethodName       = "/aggregator.Aggregator/SimulateTask"
	Aggregator_GetTokenMetadata_FullMethodName   = "/aggregator.Aggregator/GetTokenMetadata"
	Aggregator_EstimateFees_FullMethodName       = "/aggregator.Aggregator/EstimateFees"
)

// AggregatorClient is the client API for Aggregator 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 AggregatorClient interface {
	// Exchange for an Auth Key to authenticate in subsequent request
	GetKey(ctx context.Context, in *GetKeyReq, opts ...grpc.CallOption) (*KeyResp, error)
	// Get the signature format template used for authentication
	GetSignatureFormat(ctx context.Context, in *GetSignatureFormatReq, opts ...grpc.CallOption) (*GetSignatureFormatResp, error)
	// Smart Acccount Operation
	GetNonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResp, error)
	GetWallet(ctx context.Context, in *GetWalletReq, opts ...grpc.CallOption) (*GetWalletResp, error)
	SetWallet(ctx context.Context, in *SetWalletReq, opts ...grpc.CallOption) (*GetWalletResp, error)
	ListWallets(ctx context.Context, in *ListWalletReq, opts ...grpc.CallOption) (*ListWalletResp, error)
	// Withdraw funds from a smart wallet using UserOp
	WithdrawFunds(ctx context.Context, in *WithdrawFundsReq, opts ...grpc.CallOption) (*WithdrawFundsResp, error)
	// Task Management Operation
	CreateTask(ctx context.Context, in *CreateTaskReq, opts ...grpc.CallOption) (*CreateTaskResp, error)
	ListTasks(ctx context.Context, in *ListTasksReq, opts ...grpc.CallOption) (*ListTasksResp, error)
	GetTask(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Task, error)
	ListExecutions(ctx context.Context, in *ListExecutionsReq, opts ...grpc.CallOption) (*ListExecutionsResp, error)
	GetExecution(ctx context.Context, in *ExecutionReq, opts ...grpc.CallOption) (*Execution, error)
	GetExecutionStatus(ctx context.Context, in *ExecutionReq, opts ...grpc.CallOption) (*ExecutionStatusResp, error)
	CancelTask(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*CancelTaskResp, error)
	DeleteTask(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*DeleteTaskResp, error)
	TriggerTask(ctx context.Context, in *TriggerTaskReq, opts ...grpc.CallOption) (*TriggerTaskResp, error)
	// CreateSecret allow you to define a secret to be used in your tasks. The secret can be used with a special syntax of ${{secrets.name }}.
	// You can decide whether to grant secret to a single workflow or many workflow, or all of your workflow
	// By default, your secret is available across all of your tasks.
	CreateSecret(ctx context.Context, in *CreateOrUpdateSecretReq, opts ...grpc.CallOption) (*CreateSecretResp, error)
	DeleteSecret(ctx context.Context, in *DeleteSecretReq, opts ...grpc.CallOption) (*DeleteSecretResp, error)
	// Return all secrets belong to this user. Currently we don't support any fine tune or filter yet.
	// Only secret names and config data are returned. The secret value aren't returned.
	ListSecrets(ctx context.Context, in *ListSecretsReq, opts ...grpc.CallOption) (*ListSecretsResp, error)
	// For simplicity, currently only the user who create the secrets can update its value, or update its permission.
	// The current implementation is also limited, update is an override action, not an appending action. So when updating, you need to pass the whole payload
	UpdateSecret(ctx context.Context, in *CreateOrUpdateSecretReq, opts ...grpc.CallOption) (*UpdateSecretResp, error)
	// The spec of these 2 RPCs are based on the following issue:
	// Reference: https://github.com/AvaProtocol/EigenLayer-AVS/issues/150
	// GetWorkflowCount returns the total count of workflows for the given eoa addresses or a list of smart wallet addresses belongs to the eoa in the auth key
	// When passing a list of smart wallet addresses, we will return the total count of workflows belongs to all of them
	// If the smart wallet address is not found in our system, we will ignore it and not count towards the total
	// if smart wallet address doesn't belong to the eoa in the auth key, we will also ignore it and not count towards the total
	GetWorkflowCount(ctx context.Context, in *GetWorkflowCountReq, opts ...grpc.CallOption) (*GetWorkflowCountResp, error)
	// GetExecutionCount returns the total number of executions for specified workflow IDs or all workflows linked to the EOA in the auth key.
	// If no workflow IDs are provided, it counts executions for all workflows of the EOA.
	// Workflow IDs not found in the system are ignored.
	// Workflow IDs not linked to the EOA in the auth key are also ignored.
	GetExecutionCount(ctx context.Context, in *GetExecutionCountReq, opts ...grpc.CallOption) (*GetExecutionCountResp, error)
	// GetExecutionStats returns execution statistics for a specified time period
	// It counts total executions, successful executions, and failed executions
	// If no workflow IDs are provided, it counts for all workflows of the authenticated user
	GetExecutionStats(ctx context.Context, in *GetExecutionStatsReq, opts ...grpc.CallOption) (*GetExecutionStatsResp, error)
	// RunNodeWithInputs allows executing a single node with provided inputs for testing purposes
	RunNodeWithInputs(ctx context.Context, in *RunNodeWithInputsReq, opts ...grpc.CallOption) (*RunNodeWithInputsResp, error)
	// RunTrigger allows executing a single trigger for testing purposes
	RunTrigger(ctx context.Context, in *RunTriggerReq, opts ...grpc.CallOption) (*RunTriggerResp, error)
	// SimulateTask allows executing a complete task simulation including trigger and all workflow nodes
	SimulateTask(ctx context.Context, in *SimulateTaskReq, opts ...grpc.CallOption) (*Execution, error)
	// GetTokenMetadata allows looking up ERC20 token metadata by contract address
	GetTokenMetadata(ctx context.Context, in *GetTokenMetadataReq, opts ...grpc.CallOption) (*GetTokenMetadataResp, error)
	// EstimateFees provides comprehensive fee estimation for workflow deployment
	// Includes gas costs, automation fees, smart wallet creation fees, and promotional discounts
	// Called before CreateTask to help users understand total costs
	EstimateFees(ctx context.Context, in *EstimateFeesReq, opts ...grpc.CallOption) (*EstimateFeesResp, error)
}

type aggregatorClient struct {
	cc grpc.ClientConnInterface
}

func NewAggregatorClient(cc grpc.ClientConnInterface) AggregatorClient {
	return &aggregatorClient{cc}
}

func (c *aggregatorClient) GetKey(ctx context.Context, in *GetKeyReq, opts ...grpc.CallOption) (*KeyResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(KeyResp)
	err := c.cc.Invoke(ctx, Aggregator_GetKey_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetSignatureFormat(ctx context.Context, in *GetSignatureFormatReq, opts ...grpc.CallOption) (*GetSignatureFormatResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSignatureFormatResp)
	err := c.cc.Invoke(ctx, Aggregator_GetSignatureFormat_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetNonce(ctx context.Context, in *NonceRequest, opts ...grpc.CallOption) (*NonceResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NonceResp)
	err := c.cc.Invoke(ctx, Aggregator_GetNonce_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetWallet(ctx context.Context, in *GetWalletReq, opts ...grpc.CallOption) (*GetWalletResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetWalletResp)
	err := c.cc.Invoke(ctx, Aggregator_GetWallet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) SetWallet(ctx context.Context, in *SetWalletReq, opts ...grpc.CallOption) (*GetWalletResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetWalletResp)
	err := c.cc.Invoke(ctx, Aggregator_SetWallet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) ListWallets(ctx context.Context, in *ListWalletReq, opts ...grpc.CallOption) (*ListWalletResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListWalletResp)
	err := c.cc.Invoke(ctx, Aggregator_ListWallets_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) WithdrawFunds(ctx context.Context, in *WithdrawFundsReq, opts ...grpc.CallOption) (*WithdrawFundsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(WithdrawFundsResp)
	err := c.cc.Invoke(ctx, Aggregator_WithdrawFunds_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) CreateTask(ctx context.Context, in *CreateTaskReq, opts ...grpc.CallOption) (*CreateTaskResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateTaskResp)
	err := c.cc.Invoke(ctx, Aggregator_CreateTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) ListTasks(ctx context.Context, in *ListTasksReq, opts ...grpc.CallOption) (*ListTasksResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListTasksResp)
	err := c.cc.Invoke(ctx, Aggregator_ListTasks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetTask(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Task, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Task)
	err := c.cc.Invoke(ctx, Aggregator_GetTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) ListExecutions(ctx context.Context, in *ListExecutionsReq, opts ...grpc.CallOption) (*ListExecutionsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListExecutionsResp)
	err := c.cc.Invoke(ctx, Aggregator_ListExecutions_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetExecution(ctx context.Context, in *ExecutionReq, opts ...grpc.CallOption) (*Execution, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Execution)
	err := c.cc.Invoke(ctx, Aggregator_GetExecution_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetExecutionStatus(ctx context.Context, in *ExecutionReq, opts ...grpc.CallOption) (*ExecutionStatusResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ExecutionStatusResp)
	err := c.cc.Invoke(ctx, Aggregator_GetExecutionStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) CancelTask(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*CancelTaskResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CancelTaskResp)
	err := c.cc.Invoke(ctx, Aggregator_CancelTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) DeleteTask(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*DeleteTaskResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteTaskResp)
	err := c.cc.Invoke(ctx, Aggregator_DeleteTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) TriggerTask(ctx context.Context, in *TriggerTaskReq, opts ...grpc.CallOption) (*TriggerTaskResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(TriggerTaskResp)
	err := c.cc.Invoke(ctx, Aggregator_TriggerTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) CreateSecret(ctx context.Context, in *CreateOrUpdateSecretReq, opts ...grpc.CallOption) (*CreateSecretResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateSecretResp)
	err := c.cc.Invoke(ctx, Aggregator_CreateSecret_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) DeleteSecret(ctx context.Context, in *DeleteSecretReq, opts ...grpc.CallOption) (*DeleteSecretResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteSecretResp)
	err := c.cc.Invoke(ctx, Aggregator_DeleteSecret_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) ListSecrets(ctx context.Context, in *ListSecretsReq, opts ...grpc.CallOption) (*ListSecretsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSecretsResp)
	err := c.cc.Invoke(ctx, Aggregator_ListSecrets_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) UpdateSecret(ctx context.Context, in *CreateOrUpdateSecretReq, opts ...grpc.CallOption) (*UpdateSecretResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateSecretResp)
	err := c.cc.Invoke(ctx, Aggregator_UpdateSecret_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetWorkflowCount(ctx context.Context, in *GetWorkflowCountReq, opts ...grpc.CallOption) (*GetWorkflowCountResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetWorkflowCountResp)
	err := c.cc.Invoke(ctx, Aggregator_GetWorkflowCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetExecutionCount(ctx context.Context, in *GetExecutionCountReq, opts ...grpc.CallOption) (*GetExecutionCountResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetExecutionCountResp)
	err := c.cc.Invoke(ctx, Aggregator_GetExecutionCount_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetExecutionStats(ctx context.Context, in *GetExecutionStatsReq, opts ...grpc.CallOption) (*GetExecutionStatsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetExecutionStatsResp)
	err := c.cc.Invoke(ctx, Aggregator_GetExecutionStats_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) RunNodeWithInputs(ctx context.Context, in *RunNodeWithInputsReq, opts ...grpc.CallOption) (*RunNodeWithInputsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RunNodeWithInputsResp)
	err := c.cc.Invoke(ctx, Aggregator_RunNodeWithInputs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) RunTrigger(ctx context.Context, in *RunTriggerReq, opts ...grpc.CallOption) (*RunTriggerResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RunTriggerResp)
	err := c.cc.Invoke(ctx, Aggregator_RunTrigger_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) SimulateTask(ctx context.Context, in *SimulateTaskReq, opts ...grpc.CallOption) (*Execution, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Execution)
	err := c.cc.Invoke(ctx, Aggregator_SimulateTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) GetTokenMetadata(ctx context.Context, in *GetTokenMetadataReq, opts ...grpc.CallOption) (*GetTokenMetadataResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetTokenMetadataResp)
	err := c.cc.Invoke(ctx, Aggregator_GetTokenMetadata_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatorClient) EstimateFees(ctx context.Context, in *EstimateFeesReq, opts ...grpc.CallOption) (*EstimateFeesResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EstimateFeesResp)
	err := c.cc.Invoke(ctx, Aggregator_EstimateFees_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AggregatorServer is the server API for Aggregator service.
// All implementations must embed UnimplementedAggregatorServer
// for forward compatibility.
type AggregatorServer interface {
	// Exchange for an Auth Key to authenticate in subsequent request
	GetKey(context.Context, *GetKeyReq) (*KeyResp, error)
	// Get the signature format template used for authentication
	GetSignatureFormat(context.Context, *GetSignatureFormatReq) (*GetSignatureFormatResp, error)
	// Smart Acccount Operation
	GetNonce(context.Context, *NonceRequest) (*NonceResp, error)
	GetWallet(context.Context, *GetWalletReq) (*GetWalletResp, error)
	SetWallet(context.Context, *SetWalletReq) (*GetWalletResp, error)
	ListWallets(context.Context, *ListWalletReq) (*ListWalletResp, error)
	// Withdraw funds from a smart wallet using UserOp
	WithdrawFunds(context.Context, *WithdrawFundsReq) (*WithdrawFundsResp, error)
	// Task Management Operation
	CreateTask(context.Context, *CreateTaskReq) (*CreateTaskResp, error)
	ListTasks(context.Context, *ListTasksReq) (*ListTasksResp, error)
	GetTask(context.Context, *IdReq) (*Task, error)
	ListExecutions(context.Context, *ListExecutionsReq) (*ListExecutionsResp, error)
	GetExecution(context.Context, *ExecutionReq) (*Execution, error)
	GetExecutionStatus(context.Context, *ExecutionReq) (*ExecutionStatusResp, error)
	CancelTask(context.Context, *IdReq) (*CancelTaskResp, error)
	DeleteTask(context.Context, *IdReq) (*DeleteTaskResp, error)
	TriggerTask(context.Context, *TriggerTaskReq) (*TriggerTaskResp, error)
	// CreateSecret allow you to define a secret to be used in your tasks. The secret can be used with a special syntax of ${{secrets.name }}.
	// You can decide whether to grant secret to a single workflow or many workflow, or all of your workflow
	// By default, your secret is available across all of your tasks.
	CreateSecret(context.Context, *CreateOrUpdateSecretReq) (*CreateSecretResp, error)
	DeleteSecret(context.Context, *DeleteSecretReq) (*DeleteSecretResp, error)
	// Return all secrets belong to this user. Currently we don't support any fine tune or filter yet.
	// Only secret names and config data are returned. The secret value aren't returned.
	ListSecrets(context.Context, *ListSecretsReq) (*ListSecretsResp, error)
	// For simplicity, currently only the user who create the secrets can update its value, or update its permission.
	// The current implementation is also limited, update is an override action, not an appending action. So when updating, you need to pass the whole payload
	UpdateSecret(context.Context, *CreateOrUpdateSecretReq) (*UpdateSecretResp, error)
	// The spec of these 2 RPCs are based on the following issue:
	// Reference: https://github.com/AvaProtocol/EigenLayer-AVS/issues/150
	// GetWorkflowCount returns the total count of workflows for the given eoa addresses or a list of smart wallet addresses belongs to the eoa in the auth key
	// When passing a list of smart wallet addresses, we will return the total count of workflows belongs to all of them
	// If the smart wallet address is not found in our system, we will ignore it and not count towards the total
	// if smart wallet address doesn't belong to the eoa in the auth key, we will also ignore it and not count towards the total
	GetWorkflowCount(context.Context, *GetWorkflowCountReq) (*GetWorkflowCountResp, error)
	// GetExecutionCount returns the total number of executions for specified workflow IDs or all workflows linked to the EOA in the auth key.
	// If no workflow IDs are provided, it counts executions for all workflows of the EOA.
	// Workflow IDs not found in the system are ignored.
	// Workflow IDs not linked to the EOA in the auth key are also ignored.
	GetExecutionCount(context.Context, *GetExecutionCountReq) (*GetExecutionCountResp, error)
	// GetExecutionStats returns execution statistics for a specified time period
	// It counts total executions, successful executions, and failed executions
	// If no workflow IDs are provided, it counts for all workflows of the authenticated user
	GetExecutionStats(context.Context, *GetExecutionStatsReq) (*GetExecutionStatsResp, error)
	// RunNodeWithInputs allows executing a single node with provided inputs for testing purposes
	RunNodeWithInputs(context.Context, *RunNodeWithInputsReq) (*RunNodeWithInputsResp, error)
	// RunTrigger allows executing a single trigger for testing purposes
	RunTrigger(context.Context, *RunTriggerReq) (*RunTriggerResp, error)
	// SimulateTask allows executing a complete task simulation including trigger and all workflow nodes
	SimulateTask(context.Context, *SimulateTaskReq) (*Execution, error)
	// GetTokenMetadata allows looking up ERC20 token metadata by contract address
	GetTokenMetadata(context.Context, *GetTokenMetadataReq) (*GetTokenMetadataResp, error)
	// EstimateFees provides comprehensive fee estimation for workflow deployment
	// Includes gas costs, automation fees, smart wallet creation fees, and promotional discounts
	// Called before CreateTask to help users understand total costs
	EstimateFees(context.Context, *EstimateFeesReq) (*EstimateFeesResp, error)
	mustEmbedUnimplementedAggregatorServer()
}

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

func (UnimplementedAggregatorServer) GetKey(context.Context, *GetKeyReq) (*KeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetKey not implemented")
}
func (UnimplementedAggregatorServer) GetSignatureFormat(context.Context, *GetSignatureFormatReq) (*GetSignatureFormatResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSignatureFormat not implemented")
}
func (UnimplementedAggregatorServer) GetNonce(context.Context, *NonceRequest) (*NonceResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNonce not implemented")
}
func (UnimplementedAggregatorServer) GetWallet(context.Context, *GetWalletReq) (*GetWalletResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWallet not implemented")
}
func (UnimplementedAggregatorServer) SetWallet(context.Context, *SetWalletReq) (*GetWalletResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetWallet not implemented")
}
func (UnimplementedAggregatorServer) ListWallets(context.Context, *ListWalletReq) (*ListWalletResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWallets not implemented")
}
func (UnimplementedAggregatorServer) WithdrawFunds(context.Context, *WithdrawFundsReq) (*WithdrawFundsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawFunds not implemented")
}
func (UnimplementedAggregatorServer) CreateTask(context.Context, *CreateTaskReq) (*CreateTaskResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTask not implemented")
}
func (UnimplementedAggregatorServer) ListTasks(context.Context, *ListTasksReq) (*ListTasksResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTasks not implemented")
}
func (UnimplementedAggregatorServer) GetTask(context.Context, *IdReq) (*Task, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTask not implemented")
}
func (UnimplementedAggregatorServer) ListExecutions(context.Context, *ListExecutionsReq) (*ListExecutionsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListExecutions not implemented")
}
func (UnimplementedAggregatorServer) GetExecution(context.Context, *ExecutionReq) (*Execution, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExecution not implemented")
}
func (UnimplementedAggregatorServer) GetExecutionStatus(context.Context, *ExecutionReq) (*ExecutionStatusResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExecutionStatus not implemented")
}
func (UnimplementedAggregatorServer) CancelTask(context.Context, *IdReq) (*CancelTaskResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelTask not implemented")
}
func (UnimplementedAggregatorServer) DeleteTask(context.Context, *IdReq) (*DeleteTaskResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTask not implemented")
}
func (UnimplementedAggregatorServer) TriggerTask(context.Context, *TriggerTaskReq) (*TriggerTaskResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TriggerTask not implemented")
}
func (UnimplementedAggregatorServer) CreateSecret(context.Context, *CreateOrUpdateSecretReq) (*CreateSecretResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSecret not implemented")
}
func (UnimplementedAggregatorServer) DeleteSecret(context.Context, *DeleteSecretReq) (*DeleteSecretResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSecret not implemented")
}
func (UnimplementedAggregatorServer) ListSecrets(context.Context, *ListSecretsReq) (*ListSecretsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSecrets not implemented")
}
func (UnimplementedAggregatorServer) UpdateSecret(context.Context, *CreateOrUpdateSecretReq) (*UpdateSecretResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSecret not implemented")
}
func (UnimplementedAggregatorServer) GetWorkflowCount(context.Context, *GetWorkflowCountReq) (*GetWorkflowCountResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWorkflowCount not implemented")
}
func (UnimplementedAggregatorServer) GetExecutionCount(context.Context, *GetExecutionCountReq) (*GetExecutionCountResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExecutionCount not implemented")
}
func (UnimplementedAggregatorServer) GetExecutionStats(context.Context, *GetExecutionStatsReq) (*GetExecutionStatsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExecutionStats not implemented")
}
func (UnimplementedAggregatorServer) RunNodeWithInputs(context.Context, *RunNodeWithInputsReq) (*RunNodeWithInputsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunNodeWithInputs not implemented")
}
func (UnimplementedAggregatorServer) RunTrigger(context.Context, *RunTriggerReq) (*RunTriggerResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunTrigger not implemented")
}
func (UnimplementedAggregatorServer) SimulateTask(context.Context, *SimulateTaskReq) (*Execution, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SimulateTask not implemented")
}
func (UnimplementedAggregatorServer) GetTokenMetadata(context.Context, *GetTokenMetadataReq) (*GetTokenMetadataResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTokenMetadata not implemented")
}
func (UnimplementedAggregatorServer) EstimateFees(context.Context, *EstimateFeesReq) (*EstimateFeesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateFees not implemented")
}
func (UnimplementedAggregatorServer) mustEmbedUnimplementedAggregatorServer() {}
func (UnimplementedAggregatorServer) testEmbeddedByValue()                    {}

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

func RegisterAggregatorServer(s grpc.ServiceRegistrar, srv AggregatorServer) {
	// If the following call pancis, it indicates UnimplementedAggregatorServer 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(&Aggregator_ServiceDesc, srv)
}

func _Aggregator_GetKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetKeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetKey_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetKey(ctx, req.(*GetKeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetSignatureFormat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSignatureFormatReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetSignatureFormat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetSignatureFormat_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetSignatureFormat(ctx, req.(*GetSignatureFormatReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetNonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NonceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetNonce(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetNonce_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetNonce(ctx, req.(*NonceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWalletReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetWallet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetWallet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetWallet(ctx, req.(*GetWalletReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_SetWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetWalletReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).SetWallet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_SetWallet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).SetWallet(ctx, req.(*SetWalletReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_ListWallets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWalletReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).ListWallets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_ListWallets_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).ListWallets(ctx, req.(*ListWalletReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_WithdrawFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WithdrawFundsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).WithdrawFunds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_WithdrawFunds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).WithdrawFunds(ctx, req.(*WithdrawFundsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_CreateTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateTaskReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).CreateTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_CreateTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).CreateTask(ctx, req.(*CreateTaskReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_ListTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTasksReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).ListTasks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_ListTasks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).ListTasks(ctx, req.(*ListTasksReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetTask(ctx, req.(*IdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_ListExecutions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListExecutionsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).ListExecutions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_ListExecutions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).ListExecutions(ctx, req.(*ListExecutionsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetExecution_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecutionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetExecution(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetExecution_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetExecution(ctx, req.(*ExecutionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetExecutionStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecutionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetExecutionStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetExecutionStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetExecutionStatus(ctx, req.(*ExecutionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_CancelTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).CancelTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_CancelTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).CancelTask(ctx, req.(*IdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_DeleteTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).DeleteTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_DeleteTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).DeleteTask(ctx, req.(*IdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_TriggerTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TriggerTaskReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).TriggerTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_TriggerTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).TriggerTask(ctx, req.(*TriggerTaskReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_CreateSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateOrUpdateSecretReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).CreateSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_CreateSecret_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).CreateSecret(ctx, req.(*CreateOrUpdateSecretReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_DeleteSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteSecretReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).DeleteSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_DeleteSecret_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).DeleteSecret(ctx, req.(*DeleteSecretReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_ListSecrets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSecretsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).ListSecrets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_ListSecrets_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).ListSecrets(ctx, req.(*ListSecretsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_UpdateSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateOrUpdateSecretReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).UpdateSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_UpdateSecret_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).UpdateSecret(ctx, req.(*CreateOrUpdateSecretReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetWorkflowCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWorkflowCountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetWorkflowCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetWorkflowCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetWorkflowCount(ctx, req.(*GetWorkflowCountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetExecutionCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetExecutionCountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetExecutionCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetExecutionCount_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetExecutionCount(ctx, req.(*GetExecutionCountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetExecutionStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetExecutionStatsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetExecutionStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetExecutionStats_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetExecutionStats(ctx, req.(*GetExecutionStatsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_RunNodeWithInputs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunNodeWithInputsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).RunNodeWithInputs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_RunNodeWithInputs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).RunNodeWithInputs(ctx, req.(*RunNodeWithInputsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_RunTrigger_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunTriggerReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).RunTrigger(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_RunTrigger_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).RunTrigger(ctx, req.(*RunTriggerReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_SimulateTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SimulateTaskReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).SimulateTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_SimulateTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).SimulateTask(ctx, req.(*SimulateTaskReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_GetTokenMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTokenMetadataReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).GetTokenMetadata(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_GetTokenMetadata_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).GetTokenMetadata(ctx, req.(*GetTokenMetadataReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Aggregator_EstimateFees_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateFeesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatorServer).EstimateFees(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Aggregator_EstimateFees_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatorServer).EstimateFees(ctx, req.(*EstimateFeesReq))
	}
	return interceptor(ctx, in, info, handler)
}

// Aggregator_ServiceDesc is the grpc.ServiceDesc for Aggregator service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Aggregator_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "aggregator.Aggregator",
	HandlerType: (*AggregatorServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetKey",
			Handler:    _Aggregator_GetKey_Handler,
		},
		{
			MethodName: "GetSignatureFormat",
			Handler:    _Aggregator_GetSignatureFormat_Handler,
		},
		{
			MethodName: "GetNonce",
			Handler:    _Aggregator_GetNonce_Handler,
		},
		{
			MethodName: "GetWallet",
			Handler:    _Aggregator_GetWallet_Handler,
		},
		{
			MethodName: "SetWallet",
			Handler:    _Aggregator_SetWallet_Handler,
		},
		{
			MethodName: "ListWallets",
			Handler:    _Aggregator_ListWallets_Handler,
		},
		{
			MethodName: "WithdrawFunds",
			Handler:    _Aggregator_WithdrawFunds_Handler,
		},
		{
			MethodName: "CreateTask",
			Handler:    _Aggregator_CreateTask_Handler,
		},
		{
			MethodName: "ListTasks",
			Handler:    _Aggregator_ListTasks_Handler,
		},
		{
			MethodName: "GetTask",
			Handler:    _Aggregator_GetTask_Handler,
		},
		{
			MethodName: "ListExecutions",
			Handler:    _Aggregator_ListExecutions_Handler,
		},
		{
			MethodName: "GetExecution",
			Handler:    _Aggregator_GetExecution_Handler,
		},
		{
			MethodName: "GetExecutionStatus",
			Handler:    _Aggregator_GetExecutionStatus_Handler,
		},
		{
			MethodName: "CancelTask",
			Handler:    _Aggregator_CancelTask_Handler,
		},
		{
			MethodName: "DeleteTask",
			Handler:    _Aggregator_DeleteTask_Handler,
		},
		{
			MethodName: "TriggerTask",
			Handler:    _Aggregator_TriggerTask_Handler,
		},
		{
			MethodName: "CreateSecret",
			Handler:    _Aggregator_CreateSecret_Handler,
		},
		{
			MethodName: "DeleteSecret",
			Handler:    _Aggregator_DeleteSecret_Handler,
		},
		{
			MethodName: "ListSecrets",
			Handler:    _Aggregator_ListSecrets_Handler,
		},
		{
			MethodName: "UpdateSecret",
			Handler:    _Aggregator_UpdateSecret_Handler,
		},
		{
			MethodName: "GetWorkflowCount",
			Handler:    _Aggregator_GetWorkflowCount_Handler,
		},
		{
			MethodName: "GetExecutionCount",
			Handler:    _Aggregator_GetExecutionCount_Handler,
		},
		{
			MethodName: "GetExecutionStats",
			Handler:    _Aggregator_GetExecutionStats_Handler,
		},
		{
			MethodName: "RunNodeWithInputs",
			Handler:    _Aggregator_RunNodeWithInputs_Handler,
		},
		{
			MethodName: "RunTrigger",
			Handler:    _Aggregator_RunTrigger_Handler,
		},
		{
			MethodName: "SimulateTask",
			Handler:    _Aggregator_SimulateTask_Handler,
		},
		{
			MethodName: "GetTokenMetadata",
			Handler:    _Aggregator_GetTokenMetadata_Handler,
		},
		{
			MethodName: "EstimateFees",
			Handler:    _Aggregator_EstimateFees_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "avs.proto",
}
