libapplication

type ActivityInterface interface {
	// MarshalArgs() ([]byte, error)
	// UnmarshalArgs([]byte) error
	MarshalResult(interface{}) ([]byte, error)
	UnmarshalResult([]byte, interface{}) error
	Run(context.Context) (interface{}, error)
}

type ActivityRunInterface interface {
	Get(*Workflow, TransactionClient) (interface{}, error)
}

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

type AggregateInterface interface {
	Definition() *Definition
}

type Arg struct {
	Name     string
	Type     libdomain.PropertyType
	Required bool
}

type ArgData struct {
	Name     string
	Title    string
	Type     string
	Required bool
	Arg      *Arg
}

type AuthAggregate interface {
	NewFactoryInterface(libdomain.WorkflowInterface) interface{}
}

type AuthFactory interface {
	GetUserFromToken(
		*userpb.UserGetUserFromTokenQuery,
	) (*userpb.UserGetUserFromTokenResults, error)
}

type CacheClient interface {
	Set(context.Context, string, []byte, time.Duration) error
	Get(context.Context, string) ([]byte, error)
	Invalidate(context.Context, string) error
}

type CustomFunc struct {
	Name   string
	Args   []*Arg
	Result *Arg
}

type CustomFuncData struct {
	Name   string
	Title  string
	Args   []*ArgData
	Result *ArgData
}

type Definition struct {
	Aggregate      libdomain.AggregateInterface
	GenDomain      string
	Get            *RequestConfig
	Create         *RequestConfig
	Update         *RequestConfig
	Delete         *RequestConfig
	CustomQueries  []*libdomain.CustomRequest
	CustomCommands []*libdomain.CustomRequest

	Event bool
	// contains filtered or unexported fields
}

type Definitions struct {
	Prefix     string
	Repository string
	Tenant     bool
	Auth       bool
	// contains filtered or unexported fields
}

type OrchestratorClient interface {
	GetOrchestratorTransaction() interface{}
	RollbackOrchestratorTransaction(tx interface{})
	CommitOrchestratorTransaction(tx interface{})
	SearchWorkflow(string) (string, error)
	NewWorkflow(
		name string, idempotencyKey string, serializedArgs []byte,
	) (string, error)
	GetWorkflow(id string) (
		string, string, []byte, []byte, error)
	OnWorkflowError(name string) error
	OnWorkflowSuccess(name string, serializedResult []byte) error
	SearchActivity(
		workflowID string, step int,
	) ([]byte, error)
	// NewActivity(
	// 	workflowID string, step int, serializedArgs []byte,
	// ) (string, error)
	// GetActivity(id string) (		string, string, int, []byte, []byte, error)
	OnActivitySuccess(workflowID string, step int, serializedResult []byte) error
}

type ProtobufInterface interface {
	Unmarshal([]byte) error
	Marshal() ([]byte, error)
}

type RegisterEventsActivity struct {
	EventStoreClient libdomain.EventStoreClient
	Workflow         *Workflow
	Aggregate        libdomain.AggregateInterface
	Events           []*libdomain.Event
}

type RequestConfig struct {
	Groups        *[]string
	Authenticated bool
}

type StartWorkflowOptions struct {
	ID           string
	Model        string
	Function     string
	JWT          string
	JWTDecrypted *libdomain.JWTClaims
}

type TransactionClient interface {
	BeginTransaction(*Workflow, bool) error
	RollbackTransaction(*Workflow) error
	CommitTransaction(*Workflow) error
}

type WorkerInterface interface {
	RegisterWorkflow(string, string, interface{}) error
	RegisterActivity(a interface{}) error
	Run(i <-chan interface{}) error
}

type Workflow struct {
	WorkflowID   string
	WorkflowStep int
	// TenantID   string
	Transaction             interface{}
	TransactionClient       TransactionClient
	TransactionAlwaysCommit bool
	UseTenants              bool
	TenantClient            libdomain.AggregateInterface
	OrchestratorClient      OrchestratorClient
	// contains filtered or unexported fields
}

type WorkflowCache struct {
	CacheClient
	Key  string
	Item ProtobufInterface
}

type WorkflowInterface interface {
	GetName() string
	MarshalArgs() ([]byte, error)
	UnmarshalArgs([]byte) error
	MarshalResult(interface{}) ([]byte, error)
	UnmarshalResult([]byte, interface{}) error
	Run(*Workflow) (interface{}, error)
}

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

type WorkflowRunInterface interface {
	Get(context.Context) (interface{}, error)
}