connector

type ChainClassifier []Classifier

type ChangeEvent struct {
	Op    ChangeOp
	Table string
	Key   map[string]string
	Row   importflow.Record
	// Position is the source's resume token for this event (Route B: the LSN /
	// binlog position string). Empty for polling sources.
	Position string
}

type ChangeOp int

type ChangeSource interface {
	Changes(ctx context.Context, fn func(ChangeEvent) error) error
	Close() error
}

type Checkpoint struct {
	Cursor   string
	Position string
}

type CheckpointStore interface {
	Load(ctx context.Context, sourceKey string) (Checkpoint, bool, error)
	Save(ctx context.Context, sourceKey string, cp Checkpoint) error
}

type Classifier interface {
	Classify(ctx context.Context, col importflow.Column, samples []string) (PiiKind, Sensitivity, string)
}

type ColumnRule struct {
	Table       string      `json:"table"`
	Column      string      `json:"column"`
	PiiKind     PiiKind     `json:"pii_kind"`
	Sensitivity Sensitivity `json:"sensitivity"`
	Action      MaskAction  `json:"action"`
	Reason      string      `json:"reason,omitempty"` // rule id / LLM note
	Source      string      `json:"source,omitempty"` // "rule" | "llm" | "human"
}

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

type DesensitizerOptions struct {
	Tenant      string
	KeyProvider KeyProvider  // required when the plan has reversible actions
	Vault       Vault        // required when the plan has reversible actions
	TextScanner *TextScanner // defaults to NewTextScanner()
	// OnUnlisted is the action applied to a column that the plan does NOT cover
	// (no ColumnRule and not a TextScan column). The gate fails CLOSED: the
	// default is ActionDrop, so a column the signed plan never classified can
	// never leak through — even when the plan is hand-written (e.g. supplied to
	// the connector_run tool) and applied to a live source whose real columns
	// drifted from the plan. Set it to ActionRedact/ActionKeep only with intent.
	OnUnlisted MaskAction
}

type EnvKeyProvider struct{ Prefix string }

type FileKeyProvider struct{ Path string }

type KeyProvider interface {
	TenantKey(ctx context.Context, tenant string) ([]byte, error)
}

type LLMClassifier struct {
	Client graphflow.JSONGenerator
}

type MCPServerOptions struct {
	Implementation *mcp.Implementation
	Instructions   string
	Logger         *slog.Logger
}

type MaskAction string

type MaskingPlan struct {
	Columns  []ColumnRule   `json:"columns"`
	TextScan []TextScanRule `json:"text_scan,omitempty"`
	SignedBy string         `json:"signed_by,omitempty"`
	SignedAt time.Time      `json:"signed_at,omitempty"`
}

type MySQLBinlogOptions struct {
	ServerID uint32              // unique replica id for this client (required; default 1001)
	Tables   map[string][]string // table -> PK column names (optional; falls back to Table.PKColumns)
}

type PiiKind string

type PlanOptions struct {
	// DefaultAction for unclassified columns. Default-deny: ActionRedact.
	DefaultAction MaskAction
	// ActionFor overrides the action chosen for a given PII kind.
	ActionFor map[PiiKind]MaskAction
	// ScanTextColumns: columns of type "text" are also marked for free-text scanning.
	ScanTextColumns bool
}

type PollingOptions struct {
	Tables    []TableCursor
	BatchSize int // rows per table per drain; default 500
}

type PostgresCDCOptions struct {
	Publication     string              // pgoutput publication name (required)
	Slot            string              // replication slot name (required)
	Tables          map[string][]string // table -> primary-key column names (for ChangeEvent.Key)
	CreateSlot      bool                // create a permanent slot if absent (recommended true)
	StandbyInterval time.Duration       // standby status cadence; default 10s
}

type RuleClassifier struct{}

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

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

type Sensitivity int

type SourceOptions struct {
	Schema     string   // DB schema; Postgres default "public"
	Tables     []string // allow-list; empty = all base tables
	SampleSize int      // sample rows per table in Schemas(); default 5
	RowLimit   int      // max rows streamed per table; 0 = no limit
}

type StaticKeyProvider []byte

type TableCursor struct {
	Table        string
	CursorColumn string   // monotonic column, e.g. updated_at or a sequence
	KeyColumns   []string // primary key column(s)
}

type TextScanRule struct {
	Table  string `json:"table"`
	Column string `json:"column"`
}

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

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

type ToolboxOptions struct {
	Vault       Vault
	KeyProvider KeyProvider
	Tenant      string
	Classifier  Classifier // defaults to NewRuleClassifier()
}

type Vault interface {
	Put(ctx context.Context, tenant string, kind PiiKind, original string, kp KeyProvider) (token string, err error)
	Resolve(ctx context.Context, tenant string, tokens []string, kp KeyProvider) (map[string]string, error)
	Close() error
}

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

type WatcherOptions struct {
	// SourceKey is the stable checkpoint key for this (source, tableset).
	SourceKey string
	// Desensitizer applies the signed MaskingPlan. Required.
	Desensitizer *Desensitizer
	// Mapping routes rows to RAG/KG. Required; every RAG table MUST set IDColumn
	// and KG delete targets MUST key on the primary key (validated).
	Mapping importflow.MappingPlan
	// Checkpoint persists resume position. Required.
	Checkpoint CheckpointStore
	// Columns gives each table's column list for the one-row import source. If a
	// table is absent, columns are inferred from the event row's value keys.
	Columns map[string][]importflow.Column
}