engine

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

type ConfigBasedate struct {
	DatabaseURL    string `toml:"url"`
	DatabaseDriver string `toml:"driver"`
	DatabaseInit   string `toml:"init"`
}

type ConfigMail struct {
	MailSMTP     string `toml:"smtp"`
	MailSMTPPort string `toml:"port"`
	MailFrom     string `toml:"from"`
	MailPassword string `toml:"password"`
}

type ConfigRepository interface {
	GetConfig() *ConfigWorkspace
	SetConfig(config ConfigWorkspace)
	GetRedisClient() *redis.Client
	SetRedisClient(client *redis.Client)
	GetDB() (*sql.DB, error)
	SetDB(database *sql.DB)
}

type ConfigWorkspace struct {
	ConfigBasedate       ConfigBasedate    `toml:"database"`
	ConfigMail           ConfigMail        `toml:"mail"`
	URLConfig            URLConfig         `toml:"url"`
	MongoConfig          MongoConfig       `toml:"mongo"`
	PluginConfig         PluginConfig      `toml:"plugin"`
	RedisConfig          RedisConfig       `toml:"redis"`
	PgSessionConfig      PgSessionConfig   `toml:"pg_session"`
	TwilioConfig         TwilioConfig      `toml:"twilio"`
	Env                  map[string]string `toml:"env"`
	HttpsEngineConfig    HttpsConfig       `toml:"https_engine"`
	HttpsDesingnerConfig HttpsConfig       `toml:"https_designer"`
	DatabaseNflow        DatabaseNflow     `toml:"database_nflow"`
	VMPoolConfig         VMPoolConfig      `toml:"vm_pool"`
	TrackerConfig        TrackerConfig     `toml:"tracker"`
	DebugConfig          DebugConfig       `toml:"debug"`
	MonitorConfig        MonitorConfig     `toml:"monitor"`
	RateLimitConfig      RateLimitConfig   `toml:"rate_limit"`
}

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

type DBStats struct {
	TotalQueries  int64
	ActiveConns   int
	IdleConns     int
	WaitTime      time.Duration
	LastError     error
	LastErrorTime time.Time
	// contains filtered or unexported fields
}

type DatabaseNflow struct {
	Driver                      string `tom:"driver"`
	DSN                         string `tom:"dsn"`
	Query                       string `tom:"query"`
	QueryGetUser                string `tom:"QueryGetUser"`
	QueryGetApp                 string `tom:"QueryGetApp"`
	QueryGetModules             string `tom:"QueryGetModules"`
	QueryCountModulesByName     string `tom:"QueryCountModulesByName"`
	QueryGetModuleByName        string `tom:"QueryGetModuleByName"`
	QueryUpdateModModuleByName  string `tom:"QueryUpdateModModuleByName"`
	QueryUpdateFormModuleByName string `tom:"QueryUpdateFormModuleByName"`
	QueryUpdateCodeModuleByName string `tom:"QueryUpdateCodeModuleByName"`
	QueryUpdateApp              string `tom:"QueryUpdateApp"`
	QueryInsertModule           string `tom:"QueryInsertModule"`
	QueryDeleteModule           string `tom:"QueryDeleteModule"`
	QueryInsertLog              string `tom:"QueryInsertLog"`
	QueryGetToken               string `tom:"QueryGetToken"`
	QueryGetTemplateCount       string `tom:"QueryGetTemplateCount"`
	QueryGetTemplate            string `tom:"QueryGetTemplate"`
	QueryGetTemplates           string `tom:"QueryGetTemplates"`
	QueryUpdateTemplate         string `tom:"QueryUpdateTemplate"`
	QueryInsertTemplate         string `tom:"QueryInsertTemplate"`
	QueryDeleteTemplate         string `tom:"QueryDeleteTemplate"`
}

type DebugConfig struct {
	Enabled     bool   `toml:"enabled"`      // Enable debug endpoints (default: false)
	AuthToken   string `toml:"auth_token"`   // Optional auth token for debug endpoints
	AllowedIPs  string `toml:"allowed_ips"`  // Comma-separated list of allowed IPs (empty = all)
	EnablePprof bool   `toml:"enable_pprof"` // Enable Go pprof endpoints (default: false)
}

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

type HttpsConfig struct {
	Enable      bool   `tom:"enable"`
	Cert        string `tom:"cert"`
	Key         string `tom:"key"`
	Address     string `tom:"address"`
	Description string `tom:"description"`
	HTTPBasic   bool   `tom:"httpbasic"`
}

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

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

type IsolatedContext struct {
	echo.Context
	// contains filtered or unexported fields
}

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

type Module struct {
	Form string
	Mod  string
	Code string
}

type MongoConfig struct {
	URL string `tom:"url"`
}

type MonitorConfig struct {
	Enabled               bool   `toml:"enabled"`                 // Enable monitoring endpoints (default: true)
	HealthCheckPath       string `toml:"health_check_path"`       // Health check endpoint path (default: /health)
	MetricsPath           string `toml:"metrics_path"`            // Prometheus metrics path (default: /metrics)
	EnableDetailedMetrics bool   `toml:"enable_detailed_metrics"` // Include detailed metrics (default: false)
	MetricsPort           string `toml:"metrics_port"`            // Separate port for metrics (empty = same port)
}

type NflowPlugin interface {
	Run(c echo.Context, vars map[string]string, payloadIn interface{}, dromedary_data string, callback chan string) (payload_out interface{}, next string, err error)
	Name() string
	AddFeatureJS() map[string]interface{}
}

type PgSessionConfig struct {
	Url string `tom:"url"`
}

type PlaybookRepository interface {
	Get(appName string) (map[string]map[string]*model.Playbook, error)
	Set(appName string, playbooks map[string]map[string]*model.Playbook)
	NeedsReload(appName string) bool
	SetReloaded(appName string)
	LoadPlaybook(ctx context.Context, appName string) (map[string]map[string]*model.Playbook, error)
	InvalidateCache(appName string)
	InvalidateAllCache()
	GetCacheSize() int
}

type PluginConfig struct {
	Plugins []string `toml:"plugins"`
}

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

type RateLimitConfig struct {
	Enabled bool `toml:"enabled"` // Enable rate limiting (default: false)

	// IP rate limiting
	IPRateLimit     int `toml:"ip_rate_limit"`     // Requests per IP per window (default: 100)
	IPWindowMinutes int `toml:"ip_window_minutes"` // Time window in minutes (default: 1)
	IPBurstSize     int `toml:"ip_burst_size"`     // Burst size for IP limiting (default: 10)

	// Storage backend
	Backend         string `toml:"backend"`          // Backend type: "memory" or "redis" (default: "memory")
	CleanupInterval int    `toml:"cleanup_interval"` // Cleanup interval in minutes for memory backend (default: 10)

	// Response configuration
	RetryAfterHeader bool   `toml:"retry_after_header"` // Include Retry-After header (default: true)
	ErrorMessage     string `toml:"error_message"`      // Custom error message (default: "Rate limit exceeded")

	// Exclusions
	ExcludedIPs   string `toml:"excluded_ips"`   // Comma-separated IPs to exclude
	ExcludedPaths string `toml:"excluded_paths"` // Comma-separated paths to exclude
}

type RedisConfig struct {
	Host              string `tom:"host"`
	Password          string `tom:"password"`
	MaxConnectionPool int    `tom:"maxconnectionpool"`
}

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

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

type RuntimeController struct {
	*model.Controller
}

type SandboxConfig struct {
	AllowedGlobals   map[string]bool
	AllowedModules   map[string]bool
	BlockedFunctions []string
	EnableFileSystem bool
	EnableNetwork    bool
	EnableProcess    bool
}

type SessionManager interface {
	Lock()
	Unlock()
	RLock()
	RUnlock()
}

type Step interface {
	Run(cc *model.Controller, actor *model.Node, c echo.Context, vm *goja.Runtime, connectionNext string, vars model.Vars, currentProcess *process.Process, payload goja.Value) (string, goja.Value, error)
}

type StepGorutine struct {
}

type StepJS struct {
}

type StepPlugin struct {
}

type StepPluginCallback struct {
}

type SyncContext struct {
	echo.Context
	// contains filtered or unexported fields
}

type TrackerConfig struct {
	Enabled        bool `toml:"enabled"`         // Enable/disable tracker (default: false)
	Workers        int  `toml:"workers"`         // Number of worker goroutines (default: 4)
	BatchSize      int  `toml:"batch_size"`      // Batch size for database inserts (default: 100)
	FlushInterval  int  `toml:"flush_interval"`  // Flush interval in milliseconds (default: 250)
	ChannelBuffer  int  `toml:"channel_buffer"`  // Channel buffer size (default: 100000)
	VerboseLogging bool `toml:"verbose_logging"` // Enable verbose logging (default: false)
	StatsInterval  int  `toml:"stats_interval"`  // Stats reporting interval in seconds (default: 300)
}

type TrackerEntry struct {
	LogId, BoxId, BoxName, BoxType        string
	Username, IP, RealIP, URL             string
	ConnectionNext                        string
	Diff                                  time.Duration
	OrderBox                              int
	JSONPayload                           []byte
	UserAgent, QueryParam, Hostname, Host string
}

type TrackerStats struct {
	Processed   int64
	Errors      int64
	Dropped     int64
	BatchCount  int64
	LastProcess time.Time
}

type TwilioConfig struct {
	Enable          bool   `toml:"enable"`
	AccountSid      string `toml:"account_sid"`
	AuthToken       string `toml:"auth_token"`
	VerifyServiceID string `toml:"verify_service_id"`
}

type URLConfig struct {
	URLBase string `toml:"url_base"`
}

type VMFactory func() (*goja.Runtime, error)

type VMInstance struct {
	VM       *goja.Runtime
	ID       string
	InUse    bool
	LastUsed time.Time
	UseCount int64
	// contains filtered or unexported fields
}

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

type VMPoolConfig struct {
	MaxSize         int  `toml:"max_size"`         // Maximum number of VMs in pool (default: 50)
	PreloadSize     int  `toml:"preload_size"`     // Number of VMs to preload (default: max_size/2)
	IdleTimeout     int  `toml:"idle_timeout"`     // Minutes before idle VM is removed (default: 10)
	CleanupInterval int  `toml:"cleanup_interval"` // Minutes between cleanup runs (default: 5)
	EnableMetrics   bool `toml:"enable_metrics"`   // Enable VM pool metrics logging

	// Resource limits
	MaxMemoryMB         int   `toml:"max_memory_mb"`         // Max memory per VM in MB (default: 128)
	MaxExecutionSeconds int   `toml:"max_execution_seconds"` // Max execution time in seconds (default: 30)
	MaxOperations       int64 `toml:"max_operations"`        // Max JS operations (default: 10M)

	// Sandbox settings
	EnableFileSystem bool `toml:"enable_filesystem"` // Allow filesystem access (default: false)
	EnableNetwork    bool `toml:"enable_network"`    // Allow network access (default: false)
	EnableProcess    bool `toml:"enable_process"`    // Allow process access (default: false)
}

type VMResourceLimits struct {
	MaxMemoryBytes   int64         // Maximum memory in bytes (0 = no limit)
	MaxExecutionTime time.Duration // Maximum execution time (0 = no limit)
	MaxOperations    int64         // Maximum JS operations (0 = no limit)
	MaxStackDepth    int           // Maximum stack depth (0 = no limit)
	CheckInterval    int64         // How many operations between limit checks
}

type VMResourceStats struct {
	ElapsedTime    time.Duration
	OperationCount int64
	MemoryUsed     int64
	Interrupted    bool
}

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

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

type VMStats struct {
	Created   int64
	InUse     int64
	Available int64
	TotalUses int64
	Errors    int64
	// contains filtered or unexported fields
}

type WorkflowError struct {
	Message string
}