layout

type AlignGetter interface {
	Align() Alignment
}

type AlignSetter interface {
	SetAlign(align Alignment)
}

type Aligner struct {
	Alignment Alignment
}

type Alignment = alignment.Alignment

type Arrangement = arrangement.Arrangement

type ArrangementSetter interface {
	SetArrangement(Arrangement Arrangement)
}

type Arrangementer struct {
	Arrangement Arrangement
}

type BoundingRect struct {
	X, Y          unit.Dp
	Width, Height unit.Dp
}

type BoundingRectGetter interface {
	BoundingRect() BoundingRect
}

type Clip struct {
	Enabled bool
}

type ClipSetter interface {
	SetClip(enabled bool)
}

type Constraints = layout.Constraints

type Context = layout.Context

type Dimensions = layout.Dimensions

type EdgeInset layout.Inset

type EdgeInsetOffsetGetter interface {
	EdgeInsetOffset() Offset
}

type EdgeInsetSetter interface {
	SetEdgeInset(dp unit.Dp, positions ...position.Position)
}

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

type Offset struct {
	X unit.Dp
	Y unit.Dp
}

type OffsetSetter interface {
	SetOffset(dp unit.Dp, directions ...direction.Direction)
}

type Phase int

type PhaseHandler = event.Handler[Phase]

type PhaseHandlersSetter interface {
	SetPhaseHandlers(handlers ...PhaseHandler)
}

type PhaseRecorder struct {
	event.Events[Phase]
	// contains filtered or unexported fields
}

type PositionSetter interface {
	SetPosition(position position.Position)
}

type Positioner struct {
	Position position.Position
}

type Scrollable struct {
	Enabled bool
	Axis    direction.Axis
}

type ScrollableSetter interface {
	SetScrollable(axis direction.Axis, enabled bool)
}

type Spacer struct {
	Spacing unit.Dp
}

type SpacingSetter interface {
	SetSpacing(dp unit.Dp)
}

type WeightGetter interface {
	Weight() (float32, bool)
}

type WeightSetter interface {
	SetWeight(weight float32)
}