client

type ActorStateOperation struct {
	OperationType string
	Key           string
	Value         []byte
	TTLInSeconds  *int64
}

type BindingEvent struct {
	// Data is the input bindings sent
	Data []byte
	// Metadata is the input binding metadata
	Metadata map[string]string
}

type BulkStateItem struct {
	Key      string
	Value    []byte
	Etag     string
	Metadata map[string]string
	Error    string
}

type Client interface {
	// InvokeBinding invokes specific operation on the configured Dapr binding.
	// This method covers input, output, and bi-directional bindings.
	InvokeBinding(ctx context.Context, in *InvokeBindingRequest) (out *BindingEvent, err error)

	// InvokeOutputBinding invokes configured Dapr binding with data.InvokeOutputBinding
	// This method differs from InvokeBinding in that it doesn't expect any content being returned from the invoked method.
	InvokeOutputBinding(ctx context.Context, in *InvokeBindingRequest) error

	// InvokeMethod invokes service without raw data
	InvokeMethod(ctx context.Context, appID, methodName, verb string) (out []byte, err error)

	// InvokeMethodWithContent invokes service with content
	InvokeMethodWithContent(ctx context.Context, appID, methodName, verb string, content *DataContent) (out []byte, err error)

	// InvokeMethodWithCustomContent invokes app with custom content (struct + content type).
	InvokeMethodWithCustomContent(ctx context.Context, appID, methodName, verb string, contentType string, content interface{}) (out []byte, err error)

	// GetMetadata returns metadata from the sidecar.
	GetMetadata(ctx context.Context) (metadata *GetMetadataResponse, err error)

	// SetMetadata sets a key-value pair in the sidecar.
	SetMetadata(ctx context.Context, key, value string) error

	// PublishEvent publishes data onto topic in specific pubsub component.
	PublishEvent(ctx context.Context, pubsubName, topicName string, data interface{}, opts ...PublishEventOption) error

	// PublishEventfromCustomContent serializes an struct and publishes its contents as data (JSON) onto topic in specific pubsub component.
	// Deprecated: This method is deprecated and will be removed in a future version of the SDK. Please use `PublishEvent` instead.
	PublishEventfromCustomContent(ctx context.Context, pubsubName, topicName string, data interface{}) error

	// PublishEvents publishes multiple events onto topic in specific pubsub component.
	// If all events are successfully published, response Error will be nil.
	// The FailedEvents field will contain all events that failed to publish.
	PublishEvents(ctx context.Context, pubsubName, topicName string, events []interface{}, opts ...PublishEventsOption) PublishEventsResponse

	// GetSecret retrieves preconfigured secret from specified store using key.
	GetSecret(ctx context.Context, storeName, key string, meta map[string]string) (data map[string]string, err error)

	// GetBulkSecret retrieves all preconfigured secrets for this application.
	GetBulkSecret(ctx context.Context, storeName string, meta map[string]string) (data map[string]map[string]string, err error)

	// SaveState saves the raw data into store using default state options.
	SaveState(ctx context.Context, storeName, key string, data []byte, meta map[string]string, so ...StateOption) error

	// SaveState saves the raw data into store using provided state options and etag.
	SaveStateWithETag(ctx context.Context, storeName, key string, data []byte, etag string, meta map[string]string, so ...StateOption) error

	// SaveBulkState saves multiple state item to store with specified options.
	SaveBulkState(ctx context.Context, storeName string, items ...*SetStateItem) error

	// GetState retrieves state from specific store using default consistency option.
	GetState(ctx context.Context, storeName, key string, meta map[string]string) (item *StateItem, err error)

	// GetStateWithConsistency retrieves state from specific store using provided state consistency.
	GetStateWithConsistency(ctx context.Context, storeName, key string, meta map[string]string, sc StateConsistency) (item *StateItem, err error)

	// GetBulkState retrieves state for multiple keys from specific store.
	GetBulkState(ctx context.Context, storeName string, keys []string, meta map[string]string, parallelism int32) ([]*BulkStateItem, error)

	// QueryStateAlpha1 runs a query against state store.
	QueryStateAlpha1(ctx context.Context, storeName, query string, meta map[string]string) (*QueryResponse, error)

	// DeleteState deletes content from store using default state options.
	DeleteState(ctx context.Context, storeName, key string, meta map[string]string) error

	// DeleteStateWithETag deletes content from store using provided state options and etag.
	DeleteStateWithETag(ctx context.Context, storeName, key string, etag *ETag, meta map[string]string, opts *StateOptions) error

	// ExecuteStateTransaction provides way to execute multiple operations on a specified store.
	ExecuteStateTransaction(ctx context.Context, storeName string, meta map[string]string, ops []*StateOperation) error

	// GetConfigurationItem can get target configuration item by storeName and key
	GetConfigurationItem(ctx context.Context, storeName, key string, opts ...ConfigurationOpt) (*ConfigurationItem, error)

	// GetConfigurationItems can get a list of configuration item by storeName and keys
	GetConfigurationItems(ctx context.Context, storeName string, keys []string, opts ...ConfigurationOpt) (map[string]*ConfigurationItem, error)

	// SubscribeConfigurationItems can subscribe the change of configuration items by storeName and keys, and return subscription id
	SubscribeConfigurationItems(ctx context.Context, storeName string, keys []string, handler ConfigurationHandleFunction, opts ...ConfigurationOpt) (string, error)

	// UnsubscribeConfigurationItems stops the subscription with target store's and ID.
	// Deprecated: Closing the `SubscribeConfigurationItems` stream (closing the given context) will unsubscribe the client and should be used in favor of `UnsubscribeConfigurationItems`.
	// UnsubscribeConfigurationItems can stop the subscription with target store's and id
	UnsubscribeConfigurationItems(ctx context.Context, storeName string, id string, opts ...ConfigurationOpt) error

	// Subscribe subscribes to a pubsub topic and streams messages to the returned Subscription.
	// Subscription must be closed after finishing with subscribing.
	Subscribe(ctx context.Context, opts SubscriptionOptions) (*Subscription, error)

	// SubscribeWithHandler subscribes to a pubsub topic and calls the given handler on topic events.
	// The returned cancel function must be called after  finishing with subscribing.
	SubscribeWithHandler(ctx context.Context, opts SubscriptionOptions, handler SubscriptionHandleFunction) (func() error, error)

	// DeleteBulkState deletes content for multiple keys from store.
	DeleteBulkState(ctx context.Context, storeName string, keys []string, meta map[string]string) error

	// DeleteBulkStateItems deletes content for multiple items from store.
	DeleteBulkStateItems(ctx context.Context, storeName string, items []*DeleteStateItem) error

	// TryLockAlpha1 attempts to grab a lock from a lock store.
	TryLockAlpha1(ctx context.Context, storeName string, request *LockRequest) (*LockResponse, error)

	// UnlockAlpha1 deletes unlocks a lock from a lock store.
	UnlockAlpha1(ctx context.Context, storeName string, request *UnlockRequest) (*UnlockResponse, error)

	// Encrypt data read from a stream, returning a readable stream that receives the encrypted data.
	// This method returns an error if the initial call fails. Errors performed during the encryption are received by the out stream.
	Encrypt(ctx context.Context, in io.Reader, opts EncryptOptions) (io.Reader, error)

	// Decrypt data read from a stream, returning a readable stream that receives the decrypted data.
	// This method returns an error if the initial call fails. Errors performed during the encryption are received by the out stream.
	Decrypt(ctx context.Context, in io.Reader, opts DecryptOptions) (io.Reader, error)

	// Shutdown the sidecar.
	Shutdown(ctx context.Context) error

	// Wait for a  sidecar to become available for at most `timeout` seconds. Returns errWaitTimedOut if timeout is reached.
	Wait(ctx context.Context, timeout time.Duration) error

	// WithTraceID adds existing trace ID to the outgoing context.
	WithTraceID(ctx context.Context, id string) context.Context

	// WithAuthToken sets Dapr API token on the instantiated client.
	WithAuthToken(token string)

	// Close cleans up all resources created by the client.
	Close()

	// RegisterActorTimer registers an actor timer.
	RegisterActorTimer(ctx context.Context, req *RegisterActorTimerRequest) error

	// UnregisterActorTimer unregisters an actor timer.
	UnregisterActorTimer(ctx context.Context, req *UnregisterActorTimerRequest) error

	// RegisterActorReminder registers an actor reminder.
	RegisterActorReminder(ctx context.Context, req *RegisterActorReminderRequest) error

	// UnregisterActorReminder unregisters an actor reminder.
	UnregisterActorReminder(ctx context.Context, req *UnregisterActorReminderRequest) error

	// InvokeActor calls a method on an actor.
	InvokeActor(ctx context.Context, req *InvokeActorRequest) (*InvokeActorResponse, error)

	// GetActorState get actor state
	GetActorState(ctx context.Context, req *GetActorStateRequest) (data *GetActorStateResponse, err error)

	// SaveStateTransactionally save actor state
	SaveStateTransactionally(ctx context.Context, actorType, actorID string, operations []*ActorStateOperation) error

	// ImplActorClientStub is to impl user defined actor client stub
	ImplActorClientStub(actorClientStub actor.Client, opt ...config.Option)

	// ScheduleJobAlpha1 creates and schedules a job.
	ScheduleJobAlpha1(ctx context.Context, req *Job) error

	// GetJobAlpha1 returns a scheduled job.
	GetJobAlpha1(ctx context.Context, name string) (*Job, error)

	// DeleteJobAlpha1 deletes a scheduled job.
	DeleteJobAlpha1(ctx context.Context, name string) error

	// ConverseAlpha1 interacts with a conversational AI model.
	ConverseAlpha1(ctx context.Context, request conversationRequest, options ...conversationRequestOption) (*ConversationResponse, error)

	// ConverseAlpha2 interacts with a conversational AI model.
	ConverseAlpha2(ctx context.Context, request ConversationRequestAlpha2,
		options ...conversationRequestOptionAlpha2) (*ConversationResponseAlpha2, error)

	// GrpcClient returns the base grpc client if grpc is used and nil otherwise
	GrpcClient() pb.DaprClient

	GrpcClientConn() *grpc.ClientConn
}

type ConfigurationHandleFunction func(string, map[string]*ConfigurationItem)

type ConfigurationItem struct {
	Value    string
	Version  string
	Metadata map[string]string
}

type ConfigurationOpt func(map[string]string)

type ConversationInput struct {
	// The content to send to the llm.
	Content string
	// The role of the message.
	Role *string
	// Whether to Scrub PII from the input
	ScrubPII *bool
}

type ConversationInputAlpha2 struct {
	Messages []*ConversationMessageAlpha2
	ScrubPII *bool
}

type ConversationMessageAlpha2 struct {
	// oneof conversationmessagedeveloper, conversationmessagesystem, conversationmessageuser, conversationmessageassistant, conversationmessagetool
	ConversationMessageOfDeveloper *ConversationMessageOfDeveloperAlpha2
	ConversationMessageOfSystem    *ConversationMessageOfSystemAlpha2
	ConversationMessageOfUser      *ConversationMessageOfUserAlpha2
	ConversationMessageOfAssistant *ConversationMessageOfAssistantAlpha2
	ConversationMessageOfTool      *ConversationMessageOfToolAlpha2
}

type ConversationMessageContentAlpha2 struct {
	Text *string
}

type ConversationMessageOfAssistantAlpha2 struct {
	Name      *string
	Content   []*ConversationMessageContentAlpha2
	ToolCalls []*ConversationToolCallsAlpha2
}

type ConversationMessageOfDeveloperAlpha2 struct {
	Name    *string
	Content []*ConversationMessageContentAlpha2
}

type ConversationMessageOfSystemAlpha2 struct {
	Name    *string
	Content []*ConversationMessageContentAlpha2
}

type ConversationMessageOfToolAlpha2 struct {
	ToolID  *string
	Name    *string
	Content []*ConversationMessageContentAlpha2
}

type ConversationMessageOfUserAlpha2 struct {
	Name    *string
	Content []*ConversationMessageContentAlpha2
}

type ConversationRequestAlpha2 struct {
	Name        string // LLM component name
	ContextID   *string
	Inputs      []*ConversationInputAlpha2
	Parameters  map[string]*anypb.Any
	Metadata    map[string]string
	ScrubPII    *bool // Scrub PII from the output
	Temperature *float64
	Tools       []*ConversationToolsAlpha2
	ToolChoice  *ToolChoiceAlpha2
}

type ConversationResponse struct {
	ContextID string
	Outputs   []ConversationResult
}

type ConversationResponseAlpha2 struct {
	ContextID string
	Outputs   []*ConversationResultAlpha2
}

type ConversationResult struct {
	Result     string
	Parameters map[string]*anypb.Any
}

type ConversationResultAlpha2 struct {
	Choices []*ConversationResultChoicesAlpha2
}

type ConversationResultChoicesAlpha2 struct {
	FinishReason string
	Index        int64
	Message      *ConversationResultMessageAlpha2
}

type ConversationResultMessageAlpha2 struct {
	Content   string
	ToolCalls []*ConversationToolCallsAlpha2
}

type ConversationToolAlpha2 struct {
	Name      string
	Arguments string
}

type ConversationToolCallsAlpha2 struct {
	ID        string
	ToolTypes ConversationToolAlpha2
}

type ConversationToolsAlpha2 ConversationToolsFunctionAlpha2

type ConversationToolsFunctionAlpha2 struct {
	Name        string
	Description *string
	Parameters  *structpb.Struct
}

type DataContent struct {
	// Data is the input data
	Data []byte
	// ContentType is the type of the data content
	ContentType string
}

type DecryptOptions struct {
	// Name of the component. Required.
	ComponentName string
	// Name (or name/version) of the key to decrypt the message.
	// Overrides any key reference included in the message if present.
	// This is required if the message doesn't include a key reference (i.e. was created with omit_decryption_key_name set to true).
	KeyName string
}

type DeleteStateItem SetStateItem

type ETag struct {
	Value string
}

type EncryptOptions struct {
	// Name of the component. Required.
	ComponentName string
	// Name (or name/version) of the key. Required.
	KeyName string
	// Key wrapping algorithm to use. Required.
	// Supported options include: A256KW, A128CBC, A192CBC, A256CBC, RSA-OAEP-256.
	KeyWrapAlgorithm string
	// DataEncryptionCipher to use to encrypt data (optional): "aes-gcm" (default) or "chacha20-poly1305"
	DataEncryptionCipher string
	// If true, the encrypted document does not contain a key reference.
	// In that case, calls to the Decrypt method must provide a key reference (name or name/version).
	// Defaults to false.
	OmitDecryptionKeyName bool
	// Key reference to embed in the encrypted document (name or name/version).
	// This is helpful if the reference of the key used to decrypt the document is different from the one used to encrypt it.
	// If unset, uses the reference of the key used to encrypt the document (this is the default behavior).
	// This option is ignored if omit_decryption_key_name is true.
	DecryptionKeyName string
}

type FailurePolicy interface {
	GetPBFailurePolicy() *commonpb.JobFailurePolicy
}

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

type GetActorStateRequest struct {
	ActorType string
	ActorID   string
	KeyName   string
}

type GetActorStateResponse struct {
	Data []byte
}

type GetMetadataResponse struct {
	ID                   string
	ActiveActorsCount    []*MetadataActiveActorsCount
	RegisteredComponents []*MetadataRegisteredComponents
	ExtendedMetadata     map[string]string
	Subscriptions        []*MetadataSubscription
	HTTPEndpoints        []*MetadataHTTPEndpoint
}

type InvokeActorRequest struct {
	ActorType string
	ActorID   string
	Method    string
	Data      []byte
}

type InvokeActorResponse struct {
	Data []byte
}

type InvokeBindingRequest struct {
	// Name is name of binding to invoke.
	Name string
	// Operation is the name of the operation type for the binding to invoke
	Operation string
	// Data is the input bindings sent
	Data []byte
	// Metadata is the input binding metadata
	Metadata map[string]string
}

type Job struct {
	Name          string
	Schedule      *string
	Repeats       *uint32
	DueTime       *string
	TTL           *string
	Data          *anypb.Any
	FailurePolicy FailurePolicy
	Overwrite     bool
}

type JobFailurePolicyConstant struct {
	MaxRetries *uint32
	Interval   *time.Duration
}

type JobFailurePolicyDrop struct{}

type JobOption func(*Job)

type LockRequest struct {
	ResourceID      string
	LockOwner       string
	ExpiryInSeconds int32
}

type LockResponse struct {
	Success bool
}

type MetadataActiveActorsCount struct {
	Type  string
	Count int32
}

type MetadataHTTPEndpoint struct {
	Name string
}

type MetadataRegisteredComponents struct {
	Name         string
	Type         string
	Version      string
	Capabilities []string
}

type MetadataSubscription struct {
	PubsubName      string
	Topic           string
	Metadata        map[string]string
	Rules           *PubsubSubscriptionRules
	DeadLetterTopic string
}

type OperationType int32

type PublishEventOption func(*pb.PublishEventRequest)

type PublishEventsEvent struct {
	EntryID     string
	Data        []byte
	ContentType string
	Metadata    map[string]string
}

type PublishEventsOption func(*pb.BulkPublishRequest)

type PublishEventsResponse struct {
	Error        error
	FailedEvents []interface{}
}

type PubsubSubscriptionRule struct {
	Match string
	Path  string
}

type PubsubSubscriptionRules struct {
	Rules []*PubsubSubscriptionRule
}

type QueryItem struct {
	Key   string
	Value []byte
	Etag  string
	Error string
}

type QueryResponse struct {
	Results  []QueryItem
	Token    string
	Metadata map[string]string
}

type RegisterActorReminderRequest struct {
	ActorType string
	ActorID   string
	Name      string
	DueTime   string
	Period    string
	TTL       string
	Data      []byte
}

type RegisterActorTimerRequest struct {
	ActorType string
	ActorID   string
	Name      string
	DueTime   string
	Period    string
	TTL       string
	Data      []byte
	CallBack  string
}

type SetStateItem struct {
	Key      string
	Value    []byte
	Etag     *ETag
	Metadata map[string]string
	Options  *StateOptions
}

type StateConcurrency int32

type StateConsistency int32

type StateItem struct {
	Key      string
	Value    []byte
	Etag     string
	Metadata map[string]string
}

type StateOperation struct {
	Type OperationType
	Item *SetStateItem
}

type StateOption func(*StateOptions)

type StateOptions struct {
	Concurrency StateConcurrency
	Consistency StateConsistency
}

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

type SubscriptionHandleFunction func(event *common.TopicEvent) common.SubscriptionResponseStatus

type SubscriptionMessage struct {
	*common.TopicEvent
	// contains filtered or unexported fields
}

type SubscriptionOptions struct {
	PubsubName      string
	Topic           string
	DeadLetterTopic *string
	Metadata        map[string]string
}

type ToolChoiceAlpha2 string

type UnlockRequest struct {
	ResourceID string
	LockOwner  string
}

type UnlockResponse struct {
	StatusCode int32
	Status     string
}

type UnregisterActorReminderRequest struct {
	ActorType string
	ActorID   string
	Name      string
}

type UnregisterActorTimerRequest struct {
	ActorType string
	ActorID   string
	Name      string
}