dependencies: [
    .package(url: "https://github.com/swift-standards/swift-standards.git", from: "0.1.0")
]

.target(
    name: "YourTarget",
    dependencies: [
        // Umbrella - includes all modules
        .product(name: "Standards", package: "swift-standards")

        // Or individual modules
        .product(name: "Geometry", package: "swift-standards"),
        .product(name: "Predicate", package: "swift-standards"),
    ]
)

import Geometry

// Points are positions in space
let origin: Geometry<Double>.Point<2> = .zero
let target: Geometry<Double>.Point<2> = .init(x: 10, y: 20)

// Vectors are displacements between points
let displacement = target - origin  // Vector<2>

// Point + Vector = Point (moving a point)
let newPoint = origin + displacement

// Point - Point = Vector (displacement between points)
// Point + Point = Compile Error (meaningless operation)

import Predicate

// Build predicates from simple conditions
let isEven = Predicate<Int> { $0 % 2 == 0 }
let isPositive = Predicate<Int> { $0 > 0 }

// Compose with operators
let isEvenAndPositive = isEven && isPositive
let isOdd = !isEven

// Fluent factory methods
let isAdult = Predicate<Int>.greater.thanOrEqualTo(18)
let isInRange = Predicate<Int>.in.range(1...100)
let hasPrefix = Predicate<String>.has.prefix("swift-")

// Predicates are callable
isEven(4)           // true
isEvenAndPositive(4) // true
isEvenAndPositive(-4) // false

import Dimension

// Define phantom types for different domains
enum UserIDTag {}
enum OrderIDTag {}

typealias UserID = Tagged<UserIDTag, Int>
typealias OrderID = Tagged<OrderIDTag, Int>

let userId: UserID = Tagged(42)
let orderId: OrderID = Tagged(42)

// Same underlying value, but different types
// userId == orderId  // Compile error: cannot compare UserID with OrderID

func fetchUser(id: UserID) -> User { ... }
fetchUser(id: orderId)  // Compile error: expected UserID, got OrderID

// Coordinates: positions in space (X, Y, Z)
let x: Geometry<Double>.X = 10  // An x-coordinate
let y: Geometry<Double>.Y = 20  // A y-coordinate

// Displacements: directed changes (Width, Height, Depth)
let width: Geometry<Double>.Width = 5   // A horizontal displacement
let height: Geometry<Double>.Height = 3  // A vertical displacement

// Coordinate + Displacement = Coordinate
let newX = x + width  // X coordinate

// Coordinate - Coordinate = Displacement
let diff = x - Geometry<Double>.X(5)  // Width displacement

// Displacement + Displacement = Displacement
let totalWidth = width + Geometry<Double>.Width(10)

import Affine
import Algebra_Linear

// Points (affine space) - no addition, no scaling
let p1: Affine<Double>.Point<2> = .init(x: 0, y: 0)
let p2: Affine<Double>.Point<2> = .init(x: 10, y: 10)

// Vectors (linear space) - support addition and scaling
let v1: Linear<Double>.Vector<2> = .init(dx: 1, dy: 0)
let v2: Linear<Double>.Vector<2> = .init(dx: 0, dy: 1)

let sum = v1 + v2           // Vector addition
let scaled = v1 * 2.0       // Scalar multiplication
let displacement = p2 - p1  // Point difference yields vector
let moved = p1 + v1         // Point + Vector = Point

// The tag is purely a compile-time marker
public struct Tagged<Tag, RawValue> {
    public var rawValue: RawValue
}

// Geometry.X is just Tagged<Index.X.Coordinate, Scalar>
// No runtime overhead - same memory layout as the raw value

import Geometry

// Rectangle from corners
let rect = Geometry<Double>.Rectangle(
    llx: 0, lly: 0,  // lower-left
    urx: 100, ury: 50 // upper-right
)
print(rect.width)   // 100
print(rect.height)  // 50
print(rect.center)  // Point(x: 50, y: 25)

// Circle
let circle = Geometry<Double>.Circle(
    center: .init(x: 0, y: 0),
    radius: 10
)
print(circle.area)          // ~314.16
print(circle.circumference) // ~62.83
print(circle.contains(.init(x: 5, y: 5)))  // true

// Bezier curves
let bezier = Geometry<Double>.Bezier.quadratic(
    from: .init(x: 0, y: 0),
    control: .init(x: 50, y: 100),
    to: .init(x: 100, y: 0)
)
let midpoint = bezier.point(at: 0.5)

import Affine

let point: Affine<Double>.Point<2> = .init(x: 10, y: 0)

// Fluent transform API
let transform = Affine<Double>.Transform.identity
    .translated(by: .init(dx: 5, dy: 5))
    .rotated(by: .halfPi)  // 90 degrees
    .scaled(by: 2)

let transformed = transform.apply(to: point)

import TernaryLogic

// For SQL-style NULL handling
let a: Ternary = .true
let b: Ternary = .unknown
let c: Ternary = .false

a && b  // .unknown (true AND unknown = unknown)
a || b  // .true (true OR unknown = true)
b && c  // .false (unknown AND false = false)
!b      // .unknown (NOT unknown = unknown)

import Binary

// Byte serialization with endianness control
let value: UInt32 = 0x12345678

let littleEndian = value.bytes(.littleEndian)  // [0x78, 0x56, 0x34, 0x12]
let bigEndian = value.bytes(.bigEndian)        // [0x12, 0x34, 0x56, 0x78]

// Bit manipulation
let rotated = value.rotateLeft(by: 8)
let reversed = value.reverseBits

import StandardLibraryExtensions

// Safe collection access
let array = [1, 2, 3]
array[safe: 5]  // nil instead of crash

// Result builders for collections
let numbers = Array.build {
    1
    2
    if condition { 3 }
    for i in 4...6 { i }
}

// String utilities
"  hello  ".trimmed()  // "hello"
"hello world".range(of: "world")  // Range<String.Index>?

.product(name: "Standards", package: "swift-standards", traits: ["Codable"])