# 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/any.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 AnyMixin

if TYPE_CHECKING:
    from protobuf import DescFile


_AnyFields: TypeAlias = Literal["type_url", "value"]


class Any(Message[_AnyFields], AnyMixin):
    """
    `Any` contains an arbitrary serialized protocol buffer message along with a
    URL that describes the type of the serialized message.

    In its binary encoding, an `Any` is an ordinary message; but in other wire
    forms like JSON, it has a special encoding. The format of the type URL is
    described on the `type_url` field.

    Protobuf APIs provide utilities to interact with `Any` values:

    - A 'pack' operation accepts a message and constructs a generic `Any` wrapper
      around it.
    - An 'unpack' operation reads the content of an `Any` message, either into an
      existing message or a new one. Unpack operations must check the type of the
      value they unpack against the declared `type_url`.
    - An 'is' operation decides whether an `Any` contains a message of the given
      type, i.e. whether it can 'unpack' that type.

    The JSON format representation of an `Any` follows one of these cases:

    - For types without special-cased JSON encodings, the JSON format
      representation of the `Any` is the same as that of the message, with an
      additional `@type` field which contains the type URL.
    - For types with special-cased JSON encodings (typically called 'well-known'
      types, listed in https://protobuf.dev/programming-guides/json/#any), the
      JSON format representation has a key `@type` which contains the type URL
      and a key `value` which contains the JSON-serialized value.

    The text format representation of an `Any` is like a message with one field
    whose name is the type URL in brackets. For example, an `Any` containing a
    `foo.Bar` message may be written `[type.googleapis.com/foo.Bar] { a: 2 }`.

    ```proto
    message google.protobuf.Any
    ```

    Attributes:
        type_url:
            Identifies the type of the serialized Protobuf message with a URI reference
            consisting of a prefix ending in a slash and the fully-qualified type name.

            Example: type.googleapis.com/google.protobuf.StringValue

            This string must contain at least one `/` character, and the content after
            the last `/` must be the fully-qualified name of the type in canonical
            form, without a leading dot. Do not write a scheme on these URI references
            so that clients do not attempt to contact them.

            The prefix is arbitrary and Protobuf implementations are expected to
            simply strip off everything up to and including the last `/` to identify
            the type. `type.googleapis.com/` is a common default prefix that some
            legacy implementations require. This prefix does not indicate the origin of
            the type, and URIs containing it are not expected to respond to any
            requests.

            All type URL strings must be legal URI references with the additional
            restriction (for the text format) that the content of the reference
            must consist only of alphanumeric characters, percent-encoded escapes, and
            characters in the following set (not including the outer backticks):
            `/-.~_!$&()*+,;=`. Despite our allowing percent encodings, implementations
            should not unescape them to prevent confusion with existing parsers. For
            example, `type.googleapis.com%2FFoo` should be rejected.

            In the original design of `Any`, the possibility of launching a type
            resolution service at these type URLs was considered but Protobuf never
            implemented one and considers contacting these URLs to be problematic and
            a potential security issue. Do not attempt to contact type URLs.

            ```proto
            string type_url = 1;
            ```
        value:
            Holds a Protobuf serialization of the type described by type_url.

            ```proto
            bytes value = 2;
            ```
    """

    __slots__ = ("type_url", "value")

    if TYPE_CHECKING:

        def __init__(self, *, type_url: str = "", value: bytes = b"") -> None:
            pass

        type_url: str
        value: bytes


_DESC = file_desc(
    b'\n\x19google/protobuf/any.proto\x12\x0fgoogle.protobuf"6\n\x03Any\x12\x19\n\x08type_url\x18\x01 \x01(\tR\x07typeUrl\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05valueBv\n\x13com.google.protobufB\x08AnyProtoP\x01Z,google.golang.org/protobuf/types/known/anypb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3',
    [],
    {"Any": Any},
)


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