protocol

type ACMEHandler struct{}

type Adapter interface {
	// Name returns the adapter name
	Name() string

	// Type returns the adapter type (sql, http-api, nosql, certificate)
	Type() AdapterType

	// Execute performs a protocol operation
	Execute(ctx context.Context, operation Operation, config AdapterConfig) (*Result, error)

	// Validate checks if the adapter configuration is valid
	Validate(config AdapterConfig) error

	// Capabilities returns what operations this adapter supports
	Capabilities() Capabilities
}

type AdapterConfig struct {
	// Connection details (host, port, etc.)
	Connection map[string]string

	// Authentication credentials
	Auth map[string]string

	// Service-specific configuration from dsops-data
	ServiceConfig map[string]interface{}

	// Timeout and retry settings
	Timeout int // seconds
	Retries int
}

type AdapterType string

type Capabilities struct {
	// SupportedActions lists operations this adapter can perform
	SupportedActions []string

	// RequiredConfig lists required configuration fields
	RequiredConfig []string

	// OptionalConfig lists optional configuration fields
	OptionalConfig []string

	// Features describes special features
	Features map[string]bool
}

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

type CertificateHandler interface {
	GenerateCertificate(ctx context.Context, req CertificateRequest, config AdapterConfig) (*CertificateResult, error)
	VerifyCertificate(ctx context.Context, cert []byte, config AdapterConfig) error
	RevokeCertificate(ctx context.Context, serial string, config AdapterConfig) error
	ListCertificates(ctx context.Context, config AdapterConfig) ([]CertificateInfo, error)
}

type CertificateInfo struct {
	SerialNumber string
	Subject      string
	Issuer       string
	NotBefore    time.Time
	NotAfter     time.Time
	DNSNames     []string
	Status       string
}

type CertificateRequest struct {
	CommonName         string
	Organization       []string
	OrganizationalUnit []string
	Country            []string
	Province           []string
	Locality           []string
	DNSNames           []string
	EmailAddresses     []string
	IPAddresses        []string
	ValidityDays       int
	KeySize            int
}

type CertificateResult struct {
	Certificate      []byte
	PrivateKey       []byte
	CertificateChain []byte
	SerialNumber     string
	NotBefore        time.Time
	NotAfter         time.Time
}

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

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

type MongoHandler struct{}

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

type NoSQLConnection interface {
	Execute(ctx context.Context, command string, params map[string]interface{}) (interface{}, error)
	Close() error
}

type NoSQLHandler interface {
	Connect(ctx context.Context, config AdapterConfig) (NoSQLConnection, error)
	ValidateConfig(config AdapterConfig) error
}

type Operation struct {
	// Action is what to do: create, verify, rotate, revoke, list
	Action string

	// Target identifies what to operate on (e.g., "password", "api-key")
	Target string

	// Parameters contains operation-specific data
	Parameters map[string]interface{}

	// Metadata contains additional context
	Metadata map[string]string
}

type RedisHandler struct{}

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

type Result struct {
	// Success indicates if the operation succeeded
	Success bool

	// Data contains operation-specific results
	Data map[string]interface{}

	// Error message if operation failed
	Error string

	// Metadata about the operation
	Metadata map[string]string
}

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

type SelfSignedHandler struct{}