sem

type Bootstrap struct {
	Requested, Succeeded int
	SE, CILower, CIUpper []float64
}

type BootstrapError struct {
	Requested, Attempted, Succeeded int
}

type BootstrapOptions struct {
	// Iters is the replicate count B (positive).
	Iters int
	// Seed seeds the replicate draws.
	Seed uint64
	// Level is the percentile interval's level, in (0, 1).
	Level float64
	// Standardize fits every replicate to its rows z-scored with the
	// population SD — the correlation matrix and zero means — as the
	// full fit of a standardizing vector is.
	Standardize bool
	// Ctx, when non-nil, is read before every replicate: a deadline or a
	// cancel stops the bootstrap between two refits with ctx's own
	// error.
	Ctx context.Context
	// Ordinal, when non-nil, refits every replicate by an ordinal
	// estimator (FitOrdinal, or FitOrdinalGroups over two or more
	// samples) from the replicate's own two-step statistics: the
	// samples' rows hold the category codes of the full fit's coding,
	// which every replicate keeps, so a replicate that loses a category
	// (in any group) fails and is skipped — lavaan's bootstrap of a
	// categorical fit.
	Ordinal *BootstrapOrdinal
}

type BootstrapOrdinal struct {
	Estimator Estimator
	Kinds     []OrdinalKind
	Levels    []int
}

type BootstrapSample struct {
	Rows      []float64
	Label     string
	Level     int
	Reference bool
}

type ConstraintError struct {
	Op, Line string
}

type DefinedError struct {
	Name, Reason, Ref, Msg string
}

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

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

type Estimate struct {
	LVal, Op, RVal   string
	Value            float64
	StdValue         float64
	Free             bool
	SE, Z, P         float64
	CILower, CIUpper float64
	Param            string
	// Label is the parameter's label in the description ("a*x"), ""
	// for an unlabelled one (whose Param is an auto name).
	Label string
}

type Estimator string

type Fit struct {
	Model      *Model
	N          float64
	Objective  float64 // the minimised Wishart ML discrepancy F
	Iterations int
	Converged  bool
	Status     string // the solver's exit message
	Options    Options
	Sample     *mat.SymDense // S over Model.Observed
	Implied    *mat.SymDense // Σ(θ̂)
	// SampleMean and ImpliedMean are ȳ and μ(θ̂) over Model.Observed
	// (Model.MeanStructure only; nil otherwise).
	SampleMean, ImpliedMean []float64
	Estimates               []Estimate
	// Defined are the := rows (defined.go), in description order, after
	// Estimates in every table; nil without a := line.
	Defined []Estimate
	Stats   Stats

	// Ordinal is an ordinal (DWLS / WLSMV) fit's stage-1 pieces and
	// estimator intermediates (FitOrdinal); nil on an ML fit.
	Ordinal *OrdinalFit
	// contains filtered or unexported fields
}

type Gamma struct {
	// Inner is Σ w·s·sᵀ (Size × Size).
	Inner [][]float64
	// A11 is the univariate information (Cor × Cor, block diagonal by
	// variable); A21 the correlation rows' cross information (pairs ×
	// Cor); A22 the correlations' own information (one per pair).
	A11 [][]float64
	A21 [][]float64
	A22 []float64
	// WLSW is lavaan's WLS.W: the asymptotic covariance of WLSObs
	// (Size × Size). NACOV is N·WLSW.
	WLSW [][]float64
	// N is the total weight Σw.
	N float64
}

type GroupFit struct {
	// Labels are the groups' labels, in fit order.
	Labels []string
	// Groups are the per-group fits, index-aligned with Labels: each
	// one's Model, N (n_g), Objective (F_g), sample and implied moments
	// and Estimates (standard errors from the joint information). Each
	// group's Stats are zero; the joint figures are GroupFit.Stats.
	Groups []*Fit
	// N is the total row count Σ n_g.
	N float64
	// Objective is the minimised joint discrepancy Σ (n_g/N) F_g (twice
	// lavaan's fmin).
	Objective  float64
	Iterations int
	Converged  bool
	Status     string
	Options    Options
	// Stats are the joint statistics (lavaan's, over every group).
	Stats Stats
	// Chi2Group are the per-group chi-squares n_g F_g, summing to
	// Stats.Chi2.
	Chi2Group []float64
	// Defined are the := rows over the joint free vector and its
	// covariance (a label resolves to its group's parameter; a shared
	// one is one parameter), in description order; nil without a :=
	// line.
	Defined []Estimate
	// VCov is an ordinal fit's robust covariance of the joint free
	// vector (each group's OrdinalFit.Joint indexes it), and TraceUG /
	// TraceUG2 WLSMV's tr(UΓ) and tr((UΓ)²); nil and 0 on an ML fit.
	VCov              *mat.SymDense
	TraceUG, TraceUG2 float64
	// contains filtered or unexported fields
}

type GroupMoments struct {
	Label     string
	S, Raw    *mat.SymDense
	Mean      []float64
	N         float64
	Level     int
	Reference bool
}

type GroupSpecError struct {
	Param, Value, Msg string
}

type Information string

type Model struct {
	// Observed is the model's observed variables in semopy's order: the
	// sorted outputs (variables with no outgoing arrow), then the other
	// observed variables sorted. Sample and implied covariances use it.
	Observed []string
	// Inner is the non-output variables: sorted latents, then sorted
	// observed inner variables (Beta and Psi index it).
	Inner []string

	// MeanStructure is set when the fit models the means too
	// (ModelOptions.MeanStructure, or any `~ 1` statement): observed
	// intercepts (Nu, and Alpha for observed inner variables) and latent
	// means (Alpha) join the parameters, and the objective gains the
	// mean term.
	MeanStructure bool
	// contains filtered or unexported fields
}

type ModelOptions struct {
	// MeanStructure models the means: every observed intercept free
	// (an observed exogenous variable's mean fixed to its sample mean,
	// lavaan's fixed.x), every latent mean fixed to 0 unless a `f ~ 1`
	// statement frees it — lavaan's meanstructure = TRUE. A `~ 1`
	// statement in the description sets it too.
	MeanStructure bool
	// GroupEqual and GroupPartial are a multi-group model's (NewGroupModel)
	// lavaan group.equal values (GroupEqualValues) and group.partial
	// rows ("lhs op rhs", e.g. "x1~1", "f=~x2", "x1~~x2"): the
	// parameters of the named classes are one value across groups,
	// except the partial rows.
	GroupEqual, GroupPartial []string
	// Lavaan switches a covariance-only model to lavaan's conventions
	// (Model.Lavaan) with no lavaan-only syntax in the description: a
	// bootstrap (RunBootstrap) is lavaan's se = "bootstrap".
	Lavaan bool
	// Ordered names the ordered (ordinal) observed variables of a DWLS
	// / WLSMV fit (FitOrdinal), lavaan's ordered =, under the delta
	// parameterization: each is an indicator or an outcome (no outgoing
	// arrow) whose latent response has intercept 0 and implied variance
	// 1 — its residual variance is no parameter (the remainder) and
	// thresholds replace its mean. The model then follows lavaan's
	// conventions with a mean structure (lavaan's categorical default).
	// An observed exogenous variable is refused (lavaan conditions on it,
	// conditional.x), as are a `x ~ 1` or `x ~~ x` line on an ordered x.
	// Validated with an *OrdinalSpecError.
	Ordered []string
	// contains filtered or unexported fields
}

type Mult struct {
	Set    bool
	Fixed  bool
	Value  float64
	Label  string
	Groups []Mult
	// contains filtered or unexported fields
}

type Nearest struct {
	// Cov is the adjusted covariance (S's diagonal, to rounding).
	Cov *mat.SymDense
	// MinEigenvalue is the smallest eigenvalue of S's correlation form,
	// before the clip.
	MinEigenvalue float64
	// Clipped reports whether any eigenvalue was below the threshold
	// (false: Cov is S rescaled through its correlation form unchanged).
	Clipped bool
}

type Options struct {
	// Solver is the optimiser (default SolverSLSQP).
	Solver Solver
	// Information is the derivative computation (default
	// InformationDense).
	Information Information
	// Ftol is SLSQP's ftol (default 1e-6, SciPy's and semopy's).
	Ftol float64
	// MaxIter caps the iterations (default 10000 for SLSQP — semopy's
	// setting — and 500 for Fisher scoring).
	MaxIter int
	// GradTol is Fisher scoring's stop: every free gradient entry below
	// it in absolute value (default 1e-10).
	GradTol float64
	// Level is the Wald interval's level (lavaan's level), in (0, 1);
	// 0 is 0.95. It sets ci_lower / ci_upper only (a lavaan-convention
	// fit's), never an estimate, SE or p.
	Level float64
}

type OrdinalError struct {
	Var, Group int
	Reason     string
	Freq       []float64
	Msg        string
}

type OrdinalFit struct {
	// Estimator is the fit's estimator.
	Estimator Estimator
	// Stats are the two-step statistics; Gamma their asymptotic
	// covariance.
	Stats *TwoStepStats
	Gamma *Gamma
	// Obs is WLS.obs; Est the model's WLS.est at the estimate; Weight
	// the diagonal weight 1/diag(NACOV).
	Obs, Est, Weight []float64
	// Delta is ∂WLS.est/∂θ at the estimate (rows Obs, columns the free
	// vector: the model's free parameters then the thresholds).
	Delta [][]float64
	// VCov is the free vector's robust covariance.
	VCov *mat.SymDense
	// TraceUG and TraceUG2 are tr(UΓ) and tr((UΓ)²) (WLSMV).
	TraceUG, TraceUG2 float64
	// FreeKeys are the free vector's row keys (Estimate.Key of each
	// parameter's first row; the thresholds "x | tk"; a grouped fit's
	// free scale factors "x ~*~ x").
	FreeKeys []string
	// Joint is a grouped fit's map from this group's free vector to the
	// joint one (GroupFit.VCov's coordinates; a shared parameter one
	// joint index); nil ungrouped, where Delta and VCov are the fit's
	// own.
	Joint []int
}

type OrdinalGroup struct {
	Label     string
	In        TwoStepInput
	Level     int
	Reference bool
}

type OrdinalKind uint8

type OrdinalSpecError struct {
	Param, Var, Reason, Msg string
}

type PairEstimate struct {
	I, J int
	Kind PairKind
	Rho  float64
	// Bound reports an estimate pinned on its box edge (±0.999 /
	// ±0.995): the likelihood still rose toward ±1.
	Bound bool
	// ZeroCells reports a polychoric table with an empty cell.
	ZeroCells bool
	// Closed reports a closed-form polychoric (a 2 × 2 table with
	// proportional margins, two empty cells, or both thresholds 0;
	// lavaan's lav_bvord_cor_twostep_fit shortcuts).
	Closed bool
}

type PairKind uint8

type PairScore struct {
	Rho        float64
	ThI, ThJ   []float64
	VarI, VarJ float64
}

type Params struct {
	Lambda, Beta, Psi, Theta [][]float64
	Nu, Alpha                []float64
	SampleMean               []float64
	// Thresholds are an ordinal fit's raw thresholds τ per Observed
	// variable (an ordered variable's Levels − 1, nil for a numeric
	// one); nil for an ML fit. Theta's ordered diagonal is then the
	// delta parameterization's residual 1/Δ² − common (EBM scores,
	// NewEBMScorer).
	Thresholds [][]float64
}

type ScaledStats struct {
	Chi2, Chi2P                   float64
	ScalingFactor, ShiftParameter float64
	Chi2Baseline                  float64
	BaselineScalingFactor         float64
	CFI, TLI, RMSEA               float64
}

type ScoreLayout struct {
	// Th[v] is column v's first threshold (or mean) index; NTh[v] its
	// count (Levels-1, or 1 for a numeric column).
	Th, NTh []int
	// VarIdx[v] is a numeric column's variance index (-1 for ordered).
	VarIdx []int
	// Cor is the first correlation index; Size the total width.
	Cor, Size int
}

type ScoreMethod string

type Scorer struct {
	Weights []float64
	Center  []float64
	Base    float64
}

type Solver string

type Stats struct {
	DoF          float64
	DoFBaseline  float64
	Chi2         float64
	Chi2P        float64
	Chi2Baseline float64
	CFI, GFI     float64
	AGFI, NFI    float64
	TLI, RMSEA   float64
	AIC, BIC     float64
	LogLik       float64
	NParams      int
	// Scaled is WLSMV's scaled-shifted test and scaled indices (nil on
	// every other fit).
	Scaled *ScaledStats
}

type TwoStepInput struct {
	// Kinds is each column's measurement level.
	Kinds []OrdinalKind
	// Levels is each ordered column's category count (codes
	// 0..Levels-1; ignored for a numeric column). Every declared
	// category must hold weight (ReasonEmptyCategory).
	Levels []int
	// Rows are the complete observations, one value per column; an
	// ordered column holds its integer code.
	Rows [][]float64
	// Weights are per-row frequency weights; nil weighs every row 1.
	Weights []float64
}

type TwoStepStats struct {
	// N is the total weight Σw; Rows the row count.
	N    float64
	Rows int
	// Kinds and Levels echo the input.
	Kinds  []OrdinalKind
	Levels []int
	// Thresholds are each ordered column's Levels-1 thresholds (nil for
	// a numeric column); Freq its weighted category frequencies.
	Thresholds [][]float64
	Freq       [][]float64
	// Mean and Var are a numeric column's mean and ML variance (Σw
	// divisor); an ordered column's latent response is standardised (0
	// and 1).
	Mean, Var []float64
	// Cor is the full symmetric correlation matrix (unit diagonal).
	Cor [][]float64
	// Pairs are the bivariate estimates in lavaan's order.
	Pairs []PairEstimate
}