gtempo

-module(tempo@naive_datetime).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/2, from_string/1, literal/1, to_string/1, to_tuple/1, parse/2, parse_any/1, describe_parse_error/1, get_date/1, get_time/1, format/2, drop_time/1, set_offset/2, as_utc/1, as_local/1, compare/2, is_earlier/2, is_earlier_or_equal/2, is_equal/2, is_later/2, is_later_or_equal/2, difference/2, as_period/2, add/2, subtract/2, time_left_in_day/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Functions to use with the `NaiveDateTime` type in Tempo. Naive datetimes\n"
    " are datetime values without an offset or timezone value.\n"
    " \n"
    " ## Example\n"
    " \n"
    " ```gleam\n"
    " import tempo/naive_datetime\n"
    " import tempo/date\n"
    " import tempo/time\n"
    " \n"
    " pub fn get_date_and_time() {\n"
    "   naive_datetime.now_local()\n"
    "   |> naive_datetime.to_string\n"
    "   // -> \"2024-06-21T13:42:11\"\n"
    " }\n"
).

-file("src/tempo/naive_datetime.gleam", 42).
?DOC(
    " Creates a new naive datetime from a date and time value.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.new(\n"
    "   date.literal(\"2024-06-21\"), \n"
    "   time.literal(\"23:04:00.009\"),\n"
    " )\n"
    " // -> naive_datetime.literal(\"2024-06-21T23:04:00.009\")\n"
    " ```\n"
).
-spec new(tempo:date(), tempo:time()) -> tempo:naive_date_time().
new(Date, Time) ->
    tempo:naive_datetime(Date, Time).

-file("src/tempo/naive_datetime.gleam", 128).
?DOC(
    " Parses a naive datetime string in the format `YYYY-MM-DDThh:mm:ss.s`,\n"
    " `YYYY-MM-DD hh:mm:ss.s`, `YYYY-MM-DD`, `YYYY-M-D`, `YYYY/MM/DD`, \n"
    " `YYYY/M/D`, `YYYY.MM.DD`, `YYYY.M.D`, `YYYY_MM_DD`, `YYYY_M_D`, \n"
    " `YYYY MM DD`, `YYYY M D`, or `YYYYMMDD`.\n"
    " \n"
    " ## Examples\n"
    " ```gleam\n"
    " naive_datetime.from_string(\"20240612\")\n"
    " // -> Ok(naive_datetime.literal(\"2024-06-12T00:00:00\"))\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.from_string(\"2024-06-21 23:17:00\")\n"
    " // -> Ok(naive_datetime.literal(\"2024-06-21T23:17:00\"))\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.from_string(\"24-06-12|23:17:00\")\n"
    " // -> Error(tempo.NaiveDateTimeInvalidFormat)\n"
    " ```\n"
).
-spec from_string(binary()) -> {ok, tempo:naive_date_time()} |
    {error, tempo@error:naive_date_time_parse_error()}.
from_string(Datetime) ->
    Split_dt = case gleam_stdlib:contains_string(Datetime, <<"T"/utf8>>) of
        true ->
            gleam@string:split(Datetime, <<"T"/utf8>>);

        false ->
            gleam@string:split(Datetime, <<" "/utf8>>)
    end,
    case Split_dt of
        [Date, Time] ->
            gleam@result:'try'(
                begin
                    _pipe = tempo@date:from_string(Date),
                    gleam@result:map_error(
                        _pipe,
                        fun(_capture) ->
                            {naive_date_time_date_parse_error,
                                <<"Unable to parse date in input: "/utf8,
                                    Datetime/binary>>,
                                _capture}
                        end
                    )
                end,
                fun(Date@1) ->
                    gleam@result:map(
                        begin
                            _pipe@1 = tempo@time:from_string(Time),
                            gleam@result:map_error(
                                _pipe@1,
                                fun(_capture@1) ->
                                    {naive_date_time_time_parse_error,
                                        <<"Unable to parse time in input: "/utf8,
                                            Datetime/binary>>,
                                        _capture@1}
                                end
                            )
                        end,
                        fun(Time@1) -> tempo:naive_datetime(Date@1, Time@1) end
                    )
                end
            );

        [Date@2] ->
            gleam@result:map(
                begin
                    _pipe@2 = tempo@date:from_string(Date@2),
                    gleam@result:map_error(
                        _pipe@2,
                        fun(_capture@2) ->
                            {naive_date_time_date_parse_error,
                                <<"Unable to parse date in input: "/utf8,
                                    Datetime/binary>>,
                                _capture@2}
                        end
                    )
                end,
                fun(Date@3) ->
                    tempo:naive_datetime(Date@3, {time_of_day, 0})
                end
            );

        _ ->
            {error,
                {naive_date_time_invalid_format,
                    <<"Unable to determine date and time delimiter in input: "/utf8,
                        Datetime/binary>>}}
    end.

-file("src/tempo/naive_datetime.gleam", 64).
?DOC(
    " Creates a new naive datetime value from a string literal, but will panic \n"
    " if the string is invalid.\n"
    " \n"
    " Useful for declaring date literals that you know are valid within your  \n"
    " program.\n"
    "\n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:04:00.009\")\n"
    " |> naive_datetime.to_string\n"
    " // -> \"2024-06-21T23:04:00.009\"\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:04:00.009-04:00\")\n"
    " // panic\n"
    " ```\n"
).
-spec literal(binary()) -> tempo:naive_date_time().
literal(Naive_datetime) ->
    case from_string(Naive_datetime) of
        {ok, Naive_datetime@1} ->
            Naive_datetime@1;

        {error, {naive_date_time_invalid_format, _}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid naive datetime literal format"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 68});

        {error, {naive_date_time_time_parse_error, _, {time_invalid_format, _}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid time format in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 72});

        {error,
            {naive_date_time_time_parse_error,
                _,
                {time_out_of_bounds, _, {time_hour_out_of_bounds, _}}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid hour value in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 76});

        {error,
            {naive_date_time_time_parse_error,
                _,
                {time_out_of_bounds, _, {time_minute_out_of_bounds, _}}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid minute value in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 80});

        {error,
            {naive_date_time_time_parse_error,
                _,
                {time_out_of_bounds, _, {time_second_out_of_bounds, _}}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid second value in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 84});

        {error,
            {naive_date_time_time_parse_error,
                _,
                {time_out_of_bounds, _, {time_micro_second_out_of_bounds, _}}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid subsecond value in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 88});

        {error, {naive_date_time_date_parse_error, _, {date_invalid_format, _}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid date format in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 92});

        {error,
            {naive_date_time_date_parse_error,
                _,
                {date_out_of_bounds, _, {date_day_out_of_bounds, _}}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid date day in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 96});

        {error,
            {naive_date_time_date_parse_error,
                _,
                {date_out_of_bounds, _, {date_month_out_of_bounds, _}}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid date month in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 100});

        {error,
            {naive_date_time_date_parse_error,
                _,
                {date_out_of_bounds, _, {date_year_out_of_bounds, _}}}} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid date year in naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 104})
    end.

-file("src/tempo/naive_datetime.gleam", 182).
?DOC(
    " Returns a string representation of a naive datetime value in the ISO 8601\n"
    " format with millisecond precision. If a different precision is needed, \n"
    " use the `format` function. \n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.to_string\n"
    " // -> \"2024-06-21T23:17:00.000\"\n"
    " ```\n"
).
-spec to_string(tempo:naive_date_time()) -> binary().
to_string(Datetime) ->
    tempo:naive_datetime_to_string(Datetime).

-file("src/tempo/naive_datetime.gleam", 195).
?DOC(
    " Returns a tuple of the date and time values in the format used in Erlang.\n"
    " \n"
    " ## Example\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:07\")\n"
    " |> naive_datetime.to_tuple\n"
    " // -> #(#(2024, 6, 21), #(23, 17, 7))\n"
    " ```\n"
).
-spec to_tuple(tempo:naive_date_time()) -> {{integer(), integer(), integer()},
    {integer(), integer(), integer()}}.
to_tuple(Naive_datetime) ->
    {{begin
                _pipe = Naive_datetime,
                _pipe@1 = tempo:naive_datetime_get_date(_pipe),
                tempo:date_get_year(_pipe@1)
            end,
            tempo@month:to_int(
                begin
                    _pipe@2 = Naive_datetime,
                    _pipe@3 = tempo:naive_datetime_get_date(_pipe@2),
                    tempo:date_get_month(_pipe@3)
                end
            ),
            begin
                _pipe@4 = Naive_datetime,
                _pipe@5 = tempo:naive_datetime_get_date(_pipe@4),
                tempo:date_get_day(_pipe@5)
            end},
        {begin
                _pipe@6 = Naive_datetime,
                _pipe@7 = tempo:naive_datetime_get_time(_pipe@6),
                tempo:time_get_hour(_pipe@7)
            end,
            begin
                _pipe@8 = Naive_datetime,
                _pipe@9 = tempo:naive_datetime_get_time(_pipe@8),
                tempo:time_get_minute(_pipe@9)
            end,
            begin
                _pipe@10 = Naive_datetime,
                _pipe@11 = tempo:naive_datetime_get_time(_pipe@10),
                tempo:time_get_second(_pipe@11)
            end}}.

-file("src/tempo/naive_datetime.gleam", 245).
?DOC(
    " Parses a naive datetime string in the provided format. Always prefer using\n"
    " this over `parse_any`. All parsed formats must have all parts of a naive\n"
    " datetime (date and time). Use the other modules for parsing lesser\n"
    " date time values.\n"
    " \n"
    " Values can be escaped by putting brackets around them, like \"[Hello!] YYYY\".\n"
    " \n"
    " Available directives: YY (two-digit year), YYYY (four-digit year), M (month), \n"
    " MM (two-digit month), MMM (short month name), MMMM (full month name), \n"
    " D (day of the month), DD (two-digit day of the month),\n"
    " H (hour), HH (two-digit hour), h (12-hour clock hour), hh \n"
    " (two-digit 12-hour clock hour), m (minute), mm (two-digit minute),\n"
    " s (second), ss (two-digit second), SSS (millisecond), SSSS (microsecond), \n"
    " A (AM/PM), a (am/pm).\n"
    " \n"
    " ## Example\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.parse(\"2024/06/08, 13:42:11\", \"YYYY/MM/DD, HH:mm:ss\")\n"
    " // -> Ok(naive_datetime.literal(\"2024-06-08T13:42:11\"))\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.parse(\"January 13, 2024. 3:42:11\", \"MMMM DD, YYYY. H:mm:ss\")\n"
    " // -> Ok(naive_datetime.literal(\"2024-01-13T03:42:11\"))\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.parse(\"Hi! 2024 11 13 12 2 am\", \"[Hi!] YYYY M D h m a\")\n"
    " // -> Ok(naive_datetime.literal(\"2024-11-13T00:02:00\"))\n"
    " ```\n"
).
-spec parse(binary(), tempo:naive_date_time_format()) -> {ok,
        tempo:naive_date_time()} |
    {error, tempo@error:naive_date_time_parse_error()}.
parse(Str, Format) ->
    Format_str = tempo:get_naive_datetime_format_str(Format),
    gleam@result:'try'(
        begin
            _pipe = tempo:consume_format(Str, Format_str),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {naive_date_time_invalid_format, Field@0} end
            )
        end,
        fun(_use0) ->
            {Parts, _} = _use0,
            gleam@result:'try'(
                begin
                    _pipe@1 = tempo:find_date(Parts),
                    gleam@result:map_error(
                        _pipe@1,
                        fun(_capture) ->
                            {naive_date_time_date_parse_error, Str, _capture}
                        end
                    )
                end,
                fun(Date) ->
                    gleam@result:'try'(
                        begin
                            _pipe@2 = tempo:find_time(Parts),
                            gleam@result:map_error(
                                _pipe@2,
                                fun(_capture@1) ->
                                    {naive_date_time_time_parse_error,
                                        Str,
                                        _capture@1}
                                end
                            )
                        end,
                        fun(Time) -> {ok, new(Date, Time)} end
                    )
                end
            )
        end
    ).

-file("src/tempo/naive_datetime.gleam", 284).
?DOC(
    " Tries to parse a given date string without a known format. It will not \n"
    " parse two digit years and will assume the month always comes before the \n"
    " day in a date. Will leave off any time offset values present.\n"
    " \n"
    " ## Example\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.parse_any(\"2024.06.21 01:32 PM -04:00\")\n"
    " // -> Ok(naive_datetime.literal(\"2024-06-21T13:32:00\"))\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.parse_any(\"2024.06.21\")\n"
    " // -> Error(tempo.ParseMissingTime)\n"
    " ```\n"
).
-spec parse_any(binary()) -> {ok, tempo:naive_date_time()} |
    {error, tempo@error:naive_date_time_parse_error()}.
parse_any(Str) ->
    case tempo:parse_any(Str) of
        {{some, Date}, {some, Time}, _} ->
            {ok, new(Date, Time)};

        {_, none, _} ->
            {error,
                {naive_date_time_invalid_format,
                    <<"Unable to find date in "/utf8, Str/binary>>}};

        {none, _, _} ->
            {error,
                {naive_date_time_invalid_format,
                    <<"Unable to find time in "/utf8, Str/binary>>}}
    end.

-file("src/tempo/naive_datetime.gleam", 309).
?DOC(
    " Converts a naive datetime parse error to a human readable error message.\n"
    " \n"
    " ## Example\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.parse(\"2024 06 21 23:17:00\")\n"
    " |> snag.map_error(with: naive_datetime.describe_parse_error)\n"
    " // -> snag.error(\"Invalid date format in naive datetime: 2024 06 21 23:17:00\")\n"
    " ```\n"
).
-spec describe_parse_error(tempo@error:naive_date_time_parse_error()) -> binary().
describe_parse_error(Error) ->
    tempo@error:describe_naive_datetime_parse_error(Error).

-file("src/tempo/naive_datetime.gleam", 425).
?DOC(
    " Gets the date of a naive datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.get_date\n"
    " // -> date.literal(\"2024-06-21\")\n"
    " ```\n"
).
-spec get_date(tempo:naive_date_time()) -> tempo:date().
get_date(Datetime) ->
    tempo:naive_datetime_get_date(Datetime).

-file("src/tempo/naive_datetime.gleam", 438).
?DOC(
    " Gets the time of a naive datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.get_time\n"
    " // -> time.literal(\"23:17:00\")\n"
    " ```\n"
).
-spec get_time(tempo:naive_date_time()) -> tempo:time().
get_time(Datetime) ->
    tempo:naive_datetime_get_time(Datetime).

-file("src/tempo/naive_datetime.gleam", 355).
?DOC(
    " Formats a naive datetime value using the provided format string.\n"
    " Implements the same formatting directives as the great Day.js \n"
    " library: https://day.js.org/docs/en/display/format.\n"
    " \n"
    " Values can be escaped by putting brackets around them, like \"[Hello!] YYYY\".\n"
    " \n"
    " Available directives: YY (two-digit year), YYYY (four-digit year), M (month), \n"
    " MM (two-digit month), MMM (short month name), MMMM (full month name), \n"
    " D (day of the month), DD (two-digit day of the month), d (day of the week), \n"
    " dd (min day of the week), ddd (short day of week), dddd (full day of the week), \n"
    " H (hour), HH (two-digit hour), h (12-hour clock hour), hh \n"
    " (two-digit 12-hour clock hour), m (minute), mm (two-digit minute),\n"
    " s (second), ss (two-digit second), SSS (millisecond), SSSS (microsecond), \n"
    " A (AM/PM), a (am/pm).\n"
    " \n"
    " ## Example\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T13:42:11.314\")\n"
    " |> naive_datetime.format(\"ddd @ h:mm A\")\n"
    " // -> \"Fri @ 1:42 PM\"\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-03T09:02:01\")\n"
    " |> naive_datetime.format(\"YY YYYY M MM MMM MMMM D DD d dd ddd\")\n"
    " // --------------------> \"24 2024 6 06 Jun June 3 03 1 Mo Mon\"\n"
    " ```\n"
    " \n"
    " ```gleam \n"
    " naive_datetime.literal(\"2024-06-03T09:02:01.014920202\")\n"
    " |> naive_datetime.format(\"dddd SSS SSSS SSSSS\")\n"
    " // -> \"Monday 014 014920 014920202\"\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-03T13:02:01\")\n"
    " |> naive_datetime.format(\"H HH h hh m mm s ss a A [An ant]\")\n"
    " // -------------------> \"13 13 1 01 2 02 1 01 pm PM An ant\"\n"
    " ```\n"
).
-spec format(tempo:naive_date_time(), tempo:naive_date_time_format()) -> binary().
format(Naive_datetime, Format) ->
    Format_str = tempo:get_naive_datetime_format_str(Format),
    _assert_subject = gleam@regexp:from_string(
        <<"\\[([^\\]]+)\\]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|z{1,2}|S{3,4}|GMT|."/utf8>>
    ),
    {ok, Re} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail,
                        module => <<"tempo/naive_datetime"/utf8>>,
                        function => <<"format"/utf8>>,
                        line => 361})
    end,
    _pipe = gleam@regexp:scan(Re, Format_str),
    _pipe@1 = lists:reverse(_pipe),
    _pipe@6 = gleam@list:fold(_pipe@1, [], fun(Acc, Match) -> case Match of
                {match, Content, []} ->
                    [begin
                            _pipe@2 = Content,
                            _pipe@4 = tempo:date_replace_format(
                                _pipe@2,
                                begin
                                    _pipe@3 = Naive_datetime,
                                    get_date(_pipe@3)
                                end
                            ),
                            tempo:time_replace_format(
                                _pipe@4,
                                begin
                                    _pipe@5 = Naive_datetime,
                                    get_time(_pipe@5)
                                end
                            )
                        end |
                        Acc];

                {match, _, [{some, Sub}]} ->
                    [Sub | Acc];

                {match, Content@1, _} ->
                    [Content@1 | Acc]
            end end),
    gleam@string:join(_pipe@6, <<""/utf8>>).

-file("src/tempo/naive_datetime.gleam", 451).
?DOC(
    " Drops the time of a naive datetime, setting it to zero.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-13T23:17:00\")\n"
    " |> naive_datetime.drop_time\n"
    " // -> datetime.literal(\"2024-06-13T00:00:00\")\n"
    " ```\n"
).
-spec drop_time(tempo:naive_date_time()) -> tempo:naive_date_time().
drop_time(Datetime) ->
    _pipe = tempo:naive_datetime_get_date(Datetime),
    tempo:naive_datetime(_pipe, {time_of_day, 0}).

-file("src/tempo/naive_datetime.gleam", 466).
?DOC(
    " Sets a naive datetime's offset to the provided offset, leaving the date and\n"
    " time unchanged while returning a datetime value. \n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.set_offset(offset.literal(\"+10:00\"))\n"
    " // -> datetime.literal(\"2024-06-21T23:17:00+10:00\")\n"
    " ```\n"
).
-spec set_offset(tempo:naive_date_time(), tempo:offset()) -> tempo:date_time().
set_offset(Datetime, Offset) ->
    tempo:naive_datetime_set_offset(Datetime, Offset).

-file("src/tempo/naive_datetime.gleam", 397).
?DOC(
    " Sets a naive datetime's offset to UTC, leaving the date and time unchanged\n"
    " while returning a datetime value. \n"
    " Alias for `set_offset(naive_datetime, offset.utc)`.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.as_utc\n"
    " // -> datetime.literal(\"2024-06-21T23:17:00Z\")\n"
    " ```\n"
).
-spec as_utc(tempo:naive_date_time()) -> tempo:date_time().
as_utc(Datetime) ->
    set_offset(Datetime, {offset, 0}).

-file("src/tempo/naive_datetime.gleam", 412).
?DOC(
    " Sets a naive datetime's offset to the host's local offset, leaving the \n"
    " date and time unchanged while returning a datetime value. \n"
    " Alias for `set_offset(naive_datetime, offset.local())`.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.as_local\n"
    " // -> datetime.literal(\"2024-06-21T23:17:00+01:00\")\n"
    " ```\n"
).
-spec as_local(tempo:naive_date_time()) -> tempo:date_time().
as_local(Datetime) ->
    set_offset(Datetime, tempo@offset:local()).

-file("src/tempo/naive_datetime.gleam", 488).
?DOC(
    " Compares two naive datetimes.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.compare(to: naive_datetime.literal(\"2024-06-21T23:17:00\"))\n"
    " // -> order.Eq\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2023-05-11T13:15:00\")\n"
    " |> naive_datetime.compare(to: naive_datetime.literal(\"2024-06-21T23:17:00\"))\n"
    " // -> order.Lt\n"
    " ```\n"
).
-spec compare(tempo:naive_date_time(), tempo:naive_date_time()) -> gleam@order:order().
compare(A, B) ->
    tempo:naive_datetime_compare(A, B).

-file("src/tempo/naive_datetime.gleam", 512).
?DOC(
    " Checks if the first naive datetime is earlier than the second naive \n"
    " datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.is_earlier(\n"
    "   than: naive_datetime.literal(\"2024-06-21T23:17:00\"),\n"
    " )\n"
    " // -> False\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2013-06-12T23:17:00\")\n"
    " |> naive_datetime.is_earlier(\n"
    "   than: naive_datetime.literal(\"2024-06-12T23:17:00\"),\n"
    " )\n"
    " // -> True\n"
    " ```\n"
).
-spec is_earlier(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_earlier(A, B) ->
    tempo:naive_datetime_is_earlier(A, B).

-file("src/tempo/naive_datetime.gleam", 536).
?DOC(
    " Checks if the first naive datetime is earlier or equal to the second naive \n"
    " datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-08-12T23:17:00\")\n"
    " |> naive_datetime.is_earlier_or_equal(\n"
    "   to: naive_datetime.literal(\"2024-06-12T00:00:00\"),\n"
    " )\n"
    " // -> False\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.is_earlier_or_equal(\n"
    "   to: naive_datetime.literal(\"2024-06-21T23:17:00\"),\n"
    " )\n"
    " // -> True\n"
    " ```\n"
).
-spec is_earlier_or_equal(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_earlier_or_equal(A, B) ->
    tempo:naive_datetime_is_earlier_or_equal(A, B).

-file("src/tempo/naive_datetime.gleam", 562).
?DOC(
    " Checks if the first naive datetime is equal to the second naive datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.is_equal(\n"
    "   to: naive_datetime.literal(\"2024-06-21T23:17:00\"),\n"
    " )\n"
    " // -> True\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.is_equal(\n"
    "   to: naive_datetime.literal(\"2024-06-21T23:17:01\"),\n"
    " )\n"
    " // -> False\n"
    " ```\n"
).
-spec is_equal(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_equal(A, B) ->
    compare(A, B) =:= eq.

-file("src/tempo/naive_datetime.gleam", 585).
?DOC(
    " Checks if the first naive datetime is later than the second naive datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.is_later(\n"
    "   than: naive_datetime.literal(\"2024-06-21T23:17:00\"),\n"
    " )\n"
    " // -> False\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.is_later(\n"
    "   than: naive_datetime.literal(\"2022-04-12T00:00:00\"),\n"
    " )\n"
    " // -> True\n"
    " ```\n"
).
-spec is_later(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_later(A, B) ->
    compare(A, B) =:= gt.

-file("src/tempo/naive_datetime.gleam", 609).
?DOC(
    " Checks if the first naive datetime is later or equal to the second naive \n"
    " datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.is_later_or_equal(\n"
    "   to: naive_datetime.literal(\"2024-06-21T23:17:00\"),\n"
    " )\n"
    " // -> True\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2022-04-12T00:00:00\")\n"
    " |> naive_datetime.is_later_or_equal(\n"
    "   to: naive_datetime.literal(\"2024-06-21T23:17:00\"),\n"
    " )\n"
    " // -> False\n"
    " ```\n"
).
-spec is_later_or_equal(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_later_or_equal(A, B) ->
    tempo:naive_datetime_is_later_or_equal(A, B).

-file("src/tempo/naive_datetime.gleam", 637).
?DOC(
    " Returns the difference between two naive datetimes as a duration.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-16T01:16:12\")\n"
    " |> naive_datetime.difference(\n"
    "   naive_datetime.literal(\"2024-06-12T23:17:00\"),\n"
    " )\n"
    " |> duration.as_days\n"
    " // -> 3\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-16T01:18:12\")\n"
    " |> naive_datetime.difference(\n"
    "   naive_datetime.literal(\"2024-06-12T23:17:00\"),\n"
    " )\n"
    " |> duration.format\n"
    " // -> \"3 days, 2 hours, and 1 minute\"\n"
    " ```\n"
).
-spec difference(tempo:naive_date_time(), tempo:naive_date_time()) -> gleam@time@duration:duration().
difference(A, B) ->
    tempo:naive_datetime_difference(A, B).

-file("src/tempo/naive_datetime.gleam", 667).
?DOC(
    " Creates a period between two naive datetimes. The specified start and end\n"
    " datetimes will be swapped if the start datetime is later than the end\n"
    " datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.to_period(\n"
    "   start: naive_datetime.literal(\"2024-06-12T23:17:00\")\n"
    "   end: naive_datetime.literal(\"2024-06-16T01:16:12\"),\n"
    " )\n"
    " |> period.as_days\n"
    " // -> 3\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.to_period(\n"
    "   start: naive_datetime.literal(\"2024-06-12T23:17:00\"),\n"
    "   end: naive_datetime.literal(\"2024-06-16T01:18:12\"),\n"
    " )\n"
    " |> period.format\n"
    " // -> \"3 days, 2 hours, and 1 minute\"\n"
    " ```\n"
).
-spec as_period(tempo:naive_date_time(), tempo:naive_date_time()) -> tempo:period().
as_period(Start, End) ->
    tempo:period_new_naive(Start, End).

-file("src/tempo/naive_datetime.gleam", 683).
?DOC(
    " Adds a duration to a naive datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-21T23:17:00\")\n"
    " |> naive_datetime.add(duration.minutes(3))\n"
    " // -> naive_datetime.literal(\"2024-06-21T23:20:00\")\n"
    " ```\n"
).
-spec add(tempo:naive_date_time(), gleam@time@duration:duration()) -> tempo:naive_date_time().
add(Datetime, Duration_to_add) ->
    tempo:naive_datetime_add(Datetime, Duration_to_add).

-file("src/tempo/naive_datetime.gleam", 699).
?DOC(
    " Subtracts a duration from a naive datetime.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-12T23:17:00\")\n"
    " |> naive_datetime.subtract(duration.days(3))\n"
    " // -> naive_datetime.literal(\"2024-06-09T23:17:00\")\n"
    " ```\n"
).
-spec subtract(tempo:naive_date_time(), gleam@time@duration:duration()) -> tempo:naive_date_time().
subtract(Datetime, Duration_to_subtract) ->
    tempo:naive_datetime_subtract(Datetime, Duration_to_subtract).

-file("src/tempo/naive_datetime.gleam", 723).
?DOC(
    " Gets the time left in the day.\n"
    " \n"
    " Does **not** account for leap seconds like the rest of the package.\n"
    " \n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " naive_datetime.literal(\"2015-06-30T23:59:03\")\n"
    " |> naive_datetime |> tempo.naive_datetime_get_time_left_in_day\n"
    " // -> time.literal(\"00:00:57\")\n"
    " ```\n"
    " \n"
    " ```gleam\n"
    " naive_datetime.literal(\"2024-06-18T08:05:20\")\n"
    " |> naive_datetime |> tempo.naive_datetime_get_time_left_in_day\n"
    " // -> time.literal(\"15:54:40\")\n"
    " ```\n"
).
-spec time_left_in_day(tempo:naive_date_time()) -> tempo:time().
time_left_in_day(Naive_datetime) ->
    _pipe = Naive_datetime,
    _pipe@1 = tempo:naive_datetime_get_time(_pipe),
    tempo@time:left_in_day(_pipe@1).