rimportv2

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

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

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

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

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

type DetectionResult struct {
	Format     Format
	Confidence float64 // 0.0 to 1.0
	Reason     string  // Human-readable explanation
}

type Format int

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

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

type HashableBodyRaw struct {
	Data            string `json:"data"`
	CompressionType string `json:"compression_type"`
}

type HashableHTTP struct {
	Method       string           `json:"method"`
	URL          string           `json:"url"`
	Headers      []HashableHeader `json:"headers"`
	Params       []HashableParam  `json:"params"`
	BodyKind     int8             `json:"body_kind"`
	BodyRaw      *HashableBodyRaw `json:"body_raw,omitempty"`
	Description  string           `json:"description,omitempty"`
	ParentHttpID string           `json:"parent_http_id,omitempty"`
	IsDelta      bool             `json:"is_delta"`
}

type HashableHeader struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type HashableParam struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type ImportConstraints struct {
	MaxDataSizeBytes int64         // Maximum size of import data
	SupportedFormats []Format      // List of supported formats
	AllowedMimeTypes []string      // Allowed MIME types for file uploads
	Timeout          time.Duration // Operation timeout
}

type ImportDomainData struct {
	Enabled  bool
	Domain   string
	Variable string
}

type ImportMissingDataKind int32

type ImportRequest struct {
	WorkspaceID           idwrap.IDWrap
	Name                  string
	Data                  []byte
	TextData              string
	DomainData            []ImportDomainData
	DomainDataWasProvided bool // True if domainData was explicitly provided (even if empty array)
}

type ImportResponse struct {
	MissingData ImportMissingDataKind
	Domains     []string
}

type ImportResults struct {
	Flow     *mflow.Flow
	HTTPReqs []*mhttp.HTTP
	Files    []*mfile.File // ALL files: HTTP, folders, AND flow files (ContentType=Flow)

	HTTPHeaders        []*mhttp.HTTPHeader
	HTTPSearchParams   []*mhttp.HTTPSearchParam
	HTTPBodyForms      []*mhttp.HTTPBodyForm
	HTTPBodyUrlEncoded []*mhttp.HTTPBodyUrlencoded
	HTTPBodyRaws       []*mhttp.HTTPBodyRaw
	HTTPAsserts        []*mhttp.HTTPAssert

	// Flow-specific entities
	Nodes        []mflow.Node
	RequestNodes []mflow.NodeRequest
	Edges        []mflow.Edge

	// Environment variables created during import (for domain-to-variable mappings)
	CreatedEnvs []menv.Env
	CreatedVars []menv.Variable
	UpdatedVars []menv.Variable

	Domains     []string
	WorkspaceID idwrap.IDWrap
	MissingData ImportMissingDataKind

	// Tracking for deduplication to prevent redundant sync events
	DeduplicatedFiles    map[idwrap.IDWrap]bool
	DeduplicatedHTTPReqs map[idwrap.IDWrap]bool
}

type ImportServices struct {
	Workspace          sworkspace.WorkspaceService
	User               suser.UserService
	Http               *shttp.HTTPService
	Flow               *sflow.FlowService
	File               *sfile.FileService
	Env                senv.EnvironmentService
	Var                senv.VariableService
	HttpHeader         shttp.HttpHeaderService
	HttpSearchParam    *shttp.HttpSearchParamService
	HttpBodyForm       *shttp.HttpBodyFormService
	HttpBodyUrlEncoded *shttp.HttpBodyUrlEncodedService
	HttpBodyRaw        *shttp.HttpBodyRawService
	HttpAssert         *shttp.HttpAssertService
	Node               *sflow.NodeService
	NodeRequest        *sflow.NodeRequestService
	Edge               *sflow.EdgeService
}

type ImportStreamers struct {
	Flow               eventstream.SyncStreamer[rflowv2.FlowTopic, rflowv2.FlowEvent]
	Node               eventstream.SyncStreamer[rflowv2.NodeTopic, rflowv2.NodeEvent]
	Edge               eventstream.SyncStreamer[rflowv2.EdgeTopic, rflowv2.EdgeEvent]
	Http               eventstream.SyncStreamer[rhttp.HttpTopic, rhttp.HttpEvent]
	HttpHeader         eventstream.SyncStreamer[rhttp.HttpHeaderTopic, rhttp.HttpHeaderEvent]
	HttpSearchParam    eventstream.SyncStreamer[rhttp.HttpSearchParamTopic, rhttp.HttpSearchParamEvent]
	HttpBodyForm       eventstream.SyncStreamer[rhttp.HttpBodyFormTopic, rhttp.HttpBodyFormEvent]
	HttpBodyUrlEncoded eventstream.SyncStreamer[rhttp.HttpBodyUrlEncodedTopic, rhttp.HttpBodyUrlEncodedEvent]
	HttpBodyRaw        eventstream.SyncStreamer[rhttp.HttpBodyRawTopic, rhttp.HttpBodyRawEvent]
	HttpAssert         eventstream.SyncStreamer[rhttp.HttpAssertTopic, rhttp.HttpAssertEvent]
	File               eventstream.SyncStreamer[rfile.FileTopic, rfile.FileEvent]
	Env                eventstream.SyncStreamer[renv.EnvironmentTopic, renv.EnvironmentEvent]
	EnvVar             eventstream.SyncStreamer[renv.EnvironmentVariableTopic, renv.EnvironmentVariableEvent]
}

type ImportV2Deps struct {
	DB        *sql.DB
	Logger    *slog.Logger
	Services  ImportServices
	Readers   ImportV2Readers
	Streamers ImportStreamers
}

type ImportV2RPC struct {
	Logger *slog.Logger

	// Streamers for real-time updates
	FlowStream               eventstream.SyncStreamer[rflowv2.FlowTopic, rflowv2.FlowEvent]
	NodeStream               eventstream.SyncStreamer[rflowv2.NodeTopic, rflowv2.NodeEvent]
	EdgeStream               eventstream.SyncStreamer[rflowv2.EdgeTopic, rflowv2.EdgeEvent]
	HttpStream               eventstream.SyncStreamer[rhttp.HttpTopic, rhttp.HttpEvent]
	HttpHeaderStream         eventstream.SyncStreamer[rhttp.HttpHeaderTopic, rhttp.HttpHeaderEvent]
	HttpSearchParamStream    eventstream.SyncStreamer[rhttp.HttpSearchParamTopic, rhttp.HttpSearchParamEvent]
	HttpBodyFormStream       eventstream.SyncStreamer[rhttp.HttpBodyFormTopic, rhttp.HttpBodyFormEvent]
	HttpBodyUrlEncodedStream eventstream.SyncStreamer[rhttp.HttpBodyUrlEncodedTopic, rhttp.HttpBodyUrlEncodedEvent]
	HttpBodyRawStream        eventstream.SyncStreamer[rhttp.HttpBodyRawTopic, rhttp.HttpBodyRawEvent]
	HttpAssertStream         eventstream.SyncStreamer[rhttp.HttpAssertTopic, rhttp.HttpAssertEvent]
	FileStream               eventstream.SyncStreamer[rfile.FileTopic, rfile.FileEvent]
	EnvStream                eventstream.SyncStreamer[renv.EnvironmentTopic, renv.EnvironmentEvent]
	EnvVarStream             eventstream.SyncStreamer[renv.EnvironmentVariableTopic, renv.EnvironmentVariableEvent]

	// Services exposed for testing
	HttpService               *shttp.HTTPService
	FlowService               *sflow.FlowService
	FileService               *sfile.FileService
	HttpHeaderService         shttp.HttpHeaderService
	HttpSearchParamService    *shttp.HttpSearchParamService
	HttpBodyFormService       *shttp.HttpBodyFormService
	HttpBodyUrlEncodedService *shttp.HttpBodyUrlEncodedService
	HttpBodyRawService        *shttp.HttpBodyRawService
	HttpAssertService         *shttp.HttpAssertService
	NodeService               *sflow.NodeService
	NodeRequestService        *sflow.NodeRequestService
	EdgeService               *sflow.EdgeService
	EnvService                senv.EnvironmentService
	VarService                senv.VariableService
	// contains filtered or unexported fields
}

type ImportV2Readers struct {
	Workspace *sworkspace.WorkspaceReader
	User      *sworkspace.UserReader
}

type Importer interface {
	// Process and store HAR data with modern models (legacy compatibility)
	ImportAndStore(ctx context.Context, data []byte, workspaceID idwrap.IDWrap) (*harv2.HarResolved, error)
	// Process and store any supported format with automatic detection
	ImportAndStoreUnified(ctx context.Context, data []byte, workspaceID idwrap.IDWrap) (*TranslationResult, error)
	// Store individual entity types
	StoreHTTPEntities(ctx context.Context, httpReqs []*mhttp.HTTP) error
	StoreFiles(ctx context.Context, files []*mfile.File) error
	StoreFlow(ctx context.Context, flow *mflow.Flow) error
	// Store multiple flow entities using the modern flow service
	StoreFlows(ctx context.Context, flows []*mflow.Flow) error

	// StoreImportResults performs a coordinated storage of all import results (legacy)
	StoreImportResults(ctx context.Context, results *ImportResults) error

	// StoreUnifiedResults performs a coordinated storage of all unified translation results
	StoreUnifiedResults(ctx context.Context, results *TranslationResult) (map[idwrap.IDWrap]bool, map[idwrap.IDWrap]bool, []menv.Variable, []menv.Variable, error)

	// Store domain-to-variable mappings to all existing environments
	StoreDomainVariables(ctx context.Context, workspaceID idwrap.IDWrap, domainData []ImportDomainData) (createdEnvs []menv.Env, createdVars []menv.Variable, updatedVars []menv.Variable, err error)
}

type IntegrityError struct {
	EntityType string        // "file", "request_node", "http"
	EntityID   idwrap.IDWrap // ID of the problematic entity
	Field      string        // Which field has the issue
	RefID      idwrap.IDWrap // The referenced ID that is missing/invalid
	Message    string
}

type IntegrityReport struct {
	Errors []IntegrityError
}

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

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

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

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

type ServiceOption func(*Service)

type TranslationOptions struct {
	WorkspaceID       idwrap.IDWrap
	GenerateFiles     bool
	FileOrder         int
	EnableCompression bool
	CompressionType   int8
}

type TranslationResult struct {
	// Core entities
	HTTPRequests []mhttp.HTTP
	Files        []mfile.File // ALL files: HTTP, folders, AND flow files (ContentType=Flow)
	Flows        []mflow.Flow

	// Associated HTTP data (headers, params, bodies)
	Headers        []mhttp.HTTPHeader
	SearchParams   []mhttp.HTTPSearchParam
	BodyForms      []mhttp.HTTPBodyForm
	BodyUrlencoded []mhttp.HTTPBodyUrlencoded
	BodyRaw        []mhttp.HTTPBodyRaw
	Asserts        []mhttp.HTTPAssert

	// Flow-specific entities
	Nodes        []mflow.Node
	RequestNodes []mflow.NodeRequest
	Edges        []mflow.Edge

	// Flow node implementations (type-specific data)
	JSNodes        []mflow.NodeJS
	ConditionNodes []mflow.NodeIf
	ForNodes       []mflow.NodeFor
	ForEachNodes   []mflow.NodeForEach
	AINodes        []mflow.NodeAI
	FlowVariables  []mflow.FlowVariable

	// Variables (collection or environment level)
	Variables []menv.Variable

	// Metadata
	DetectedFormat Format
	Domains        []string
	ProcessedAt    int64
	WorkspaceID    idwrap.IDWrap
}

type Translator interface {
	// Translate converts input data to the unified TranslationResult format
	Translate(ctx context.Context, data []byte, workspaceID idwrap.IDWrap) (*TranslationResult, error)

	// GetFormat returns the format this translator handles
	GetFormat() Format

	// Validate checks if the data is valid for this format
	Validate(data []byte) error
}

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

type URLFetcher interface {
	Fetch(ctx context.Context, rawURL string) ([]byte, error)
}

type ValidationError struct {
	Field   string
	Message string
	Err     error
}

type Validator interface {
	ValidateImportRequest(ctx context.Context, req *ImportRequest) error
	ValidateWorkspaceAccess(ctx context.Context, workspaceID idwrap.IDWrap) error
	ValidateDataSize(ctx context.Context, data []byte) error
	ValidateFormatSupport(ctx context.Context, format Format) error
}

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