const document = try microwave.parse.fromSlice(allocator, toml_text);
defer document.deinit(); // all pointers will be freed using the created internal arena

// use document.root_table

const document = try microwave.parse.fromReader(allocator, file.reader());
defer document.deinit();

// use document.root_table

var owned_tree = try microwave.parse.fromSliceOwned(allocator, toml_text); // or .fromReaderOwned
defer microwave.parse.deinitTable(allocator, &owned_tree);

// use owned_tree

pub const Value = union(enum) {
    pub const Table = struct {
        keys: std.StringArrayHashMapUnmanaged(Value),
    };

    pub const Array = std.ArrayListUnmanaged(Value);
    pub const ArrayOfTables = std.ArrayListUnmanaged(Table);

    pub const DateTime = struct {
        date: ?[]const u8 = null,
        time: ?[]const u8 = null,
        offset: ?[]const u8 = null,

        pub fn dupe(self: DateTime, allocator: std.mem.Allocator) !DateTime;
        pub fn deinit(self: DateTime, allocator: std.mem.Allocator) ;
    };

    none: void,
    table: Table,
    array: Array,
    array_of_tables: ArrayOfTables,
    string: []const u8,
    integer: i64,
    float: f64,
    boolean: bool,
    date_time: DateTime,

    pub fn dupeRecursive(self: Value, allocator: std.mem.Allocator) !Value;
    pub fn deinitRecursive(self: *Value, allocator: std.mem.Allocator) void;
};

const Dog = struct {
    pub const Friend = struct {
        name: []const u8,
    };

    name: []const u8,
    cross_breeds: []const []const u8,
    age: i64,

    friends: []Friend,
    
    vet_info: microwave.parse.Value.Table,
}

const dog = try microwave.Populate(Dog).createFromSlice(allocator, toml_text); // or .createFromReader
defer dog.deinit();

const Animal = union(enum) {
    dog: struct {
        name: []const u8,
        breed: []const u8,
    },
    cat: struct {
        name: []const u8,
        number_of_colours: usize,
    },
};

const animal = try microwave.Populate(Animal).createFromSlice(allocator, toml_text);
defer animal.deinit();

const Person = struct {
    name: []const u8,
    age: i64,
    salary: f64,
    job: ?[]const u8, // can be missing from the TOML file
};

const person = try microwave.Populate(Person).createFromSlice(allocator, toml_text);
defer person.deinit();

var dog = try microwave.Populate(Dog).createFromSliceOwned(allocator, toml_text);
defer microwave.Populate(Dog).deinitRecursive(allocator, &dog);

var dog: Dog = undefined;
try microwave.Populate(Dog).intoFromSliceOwned(allocator, &dog); // or .intoFromReaderOwned
defer microwave.Populate(Dog).deinitRecursive(allocator, &dog);

try microwave.stringify.write(allocator, dog, file.writer());

try microwave.stringify.writeTable(allocator, root_table, file.writer());

var stream: microwave.write_stream.Stream(@TypeOf(file.writer()), .{
    .newlines = .lf,
    .unicode_full_escape_strings = false,
    .format_float_options = .{
        .mode = .scientific,
        .precision = null,
    },
    .date_time_separator = .t,
}) = .{
    .underlying_writer = file.writer(),
    .allocator = allocator,
};
defer stream.deinit();

pub fn beginDeepKeyPair(self: *Stream, key_parts: []const []const u8) !void;
pub fn beginKeyPair(self: *Stream, key_name: []const u8) !void;

pub fn writeString(self: *Stream, string: []const u8) !void;
pub fn writeInteger(self: *Stream, integer: i64) !void;
pub fn writeFloat(self: *Stream, float: f64) !void;
pub fn writeBoolean(self: *Stream, boolean: bool) !void;
pub fn writeDateTime(self: *Stream, date_time: parse.Value.DateTime) !void;

pub fn beginArray(self: *Stream) !void;
pub fn arrayLine(self: *Stream) !void;
pub fn endArray(self: *Stream) !void;

pub fn beginInlineTable(self: *Stream) !void;
pub fn endInlineTable(self: *Stream) !void;

pub fn writeDeepTable(self: *Stream, key_parts: []const []const u8) !void;
pub fn writeTable(self: *Stream, key_name: []const u8) !void;

pub fn writeDeepManyTable(self: *Stream, key_parts: []const []const u8) !void;
pub fn writeManyTable(self: *Stream, key_name: []const u8) !void;

var scanner: microwave.Scanner = .{ .buffer = slice };

while (try scanner.next()) |token| {
    // token.kind, token.range.start, token.range.end

    // modify state with scanner.setState(state)
}

pub const Error = error{ UnexpectedEndOfBuffer, UnexpectedByte };

var scanner = microwave.Scanner.bufferedReaderScanner(file.reader());

// use scanner.next() in the same way

pub const Error = error{ UnexpectedEndOfBuffer, UnexpectedByte, BufferTooSmall };

while (try scanner.next()) |token| {
    if (token.kind == .table_start) {
        scanner.setState(.table_key);
    }
    if (token.kind == .table_end) {
        scanner.setState(.root);
    }
}

var scanner = microwave.Scanner.BufferedReaderScanner(8192, @TypeOf(file.reader())) = .{
    .reader = file.reader(),
};

while (try scanner.next()) |token| {
    if (token.kind == .string) {
        std.log.info("Found string! {s}", .{ scanner.tokenContents(token) });
    }
}