# Copyright (c) 2025-2026 Buf Technologies, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Generated from google/protobuf/duration.proto. DO NOT EDIT.
# Generated by protoc-gen-py v0.1.1 with parameter "no_fmt_off".
# ruff: noqa: PGH004
# ruff: noqa

from __future__ import annotations

from typing import Literal, TYPE_CHECKING, TypeAlias

from protobuf import Message
from protobuf._codegen import file_desc
from protobuf.wkt._mixin import DurationMixin

if TYPE_CHECKING:
    from protobuf import DescFile


_DurationFields: TypeAlias = Literal["seconds", "nanos"]


class Duration(Message[_DurationFields], DurationMixin):
    """
    A Duration represents a signed, fixed-length span of time represented
    as a count of seconds and fractions of seconds at nanosecond
    resolution. It is independent of any calendar and concepts like "day"
    or "month". It is related to Timestamp in that the difference between
    two Timestamp values is a Duration and it can be added or subtracted
    from a Timestamp. Range is approximately +-10,000 years.

    # Examples

    Example 1: Compute Duration from two Timestamps in pseudo code.

        Timestamp start = ...;
        Timestamp end = ...;
        Duration duration = ...;

        duration.seconds = end.seconds - start.seconds;
        duration.nanos = end.nanos - start.nanos;

        if (duration.seconds < 0 && duration.nanos > 0) {
          duration.seconds += 1;
          duration.nanos -= 1000000000;
        } else if (duration.seconds > 0 && duration.nanos < 0) {
          duration.seconds -= 1;
          duration.nanos += 1000000000;
        }

    Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.

        Timestamp start = ...;
        Duration duration = ...;
        Timestamp end = ...;

        end.seconds = start.seconds + duration.seconds;
        end.nanos = start.nanos + duration.nanos;

        if (end.nanos < 0) {
          end.seconds -= 1;
          end.nanos += 1000000000;
        } else if (end.nanos >= 1000000000) {
          end.seconds += 1;
          end.nanos -= 1000000000;
        }

    Example 3: Compute Duration from datetime.timedelta in Python.

        td = datetime.timedelta(days=3, minutes=10)
        duration = Duration()
        duration.FromTimedelta(td)

    # JSON Mapping

    In JSON format, the Duration type is encoded as a string rather than an
    object, where the string ends in the suffix "s" (indicating seconds) and
    is preceded by the number of seconds, with nanoseconds expressed as
    fractional seconds. For example, 3 seconds with 0 nanoseconds should be
    encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
    be expressed in JSON format as "3.000000001s", and 3 seconds and 1
    microsecond should be expressed in JSON format as "3.000001s".


    ```proto
    message google.protobuf.Duration
    ```

    Attributes:
        seconds:
            Signed seconds of the span of time. Must be from -315,576,000,000
            to +315,576,000,000 inclusive. Note: these bounds are computed from:
            60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

            ```proto
            int64 seconds = 1;
            ```
        nanos:
            Signed fractions of a second at nanosecond resolution of the span
            of time. Durations less than one second are represented with a 0
            `seconds` field and a positive or negative `nanos` field. For durations
            of one second or more, a non-zero value for the `nanos` field must be
            of the same sign as the `seconds` field. Must be from -999,999,999
            to +999,999,999 inclusive.

            ```proto
            int32 nanos = 2;
            ```
    """

    __slots__ = ("seconds", "nanos")

    if TYPE_CHECKING:

        def __init__(self, *, seconds: int = 0, nanos: int = 0) -> None:
            pass

        seconds: int
        nanos: int


_DESC = file_desc(
    b'\n\x1egoogle/protobuf/duration.proto\x12\x0fgoogle.protobuf":\n\x08Duration\x12\x18\n\x07seconds\x18\x01 \x01(\x03R\x07seconds\x12\x14\n\x05nanos\x18\x02 \x01(\x05R\x05nanosB\x83\x01\n\x13com.google.protobufB\rDurationProtoP\x01Z1google.golang.org/protobuf/types/known/durationpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3',
    [],
    {"Duration": Duration},
)


def desc() -> DescFile:
    """Returns the descriptor for the file `google/protobuf/duration.proto`."""
    return _DESC