// Generated by Lisette bindgen
// Source: encoding/json (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.20

import "go:bytes"
import "go:io"
import "go:reflect"

/// Compact appends to dst the JSON-encoded src with
/// insignificant space characters elided.
pub fn Compact(dst: Ref<bytes.Buffer>, src: Slice<uint8>) -> Result<(), error>

/// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
/// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
/// so that the JSON will be safe to embed inside HTML <script> tags.
/// For historical reasons, web browsers don't honor standard HTML
/// escaping within <script> tags, so an alternative JSON encoding must be used.
pub fn HTMLEscape(dst: Ref<bytes.Buffer>, src: Slice<uint8>)

/// Indent appends to dst an indented form of the JSON-encoded src.
/// Each element in a JSON object or array begins on a new,
/// indented line beginning with prefix followed by one or more
/// copies of indent according to the indentation nesting.
/// The data appended to dst does not begin with the prefix nor
/// any indentation, to make it easier to embed inside other formatted JSON data.
/// Although leading space characters (space, tab, carriage return, newline)
/// at the beginning of src are dropped, trailing space characters
/// at the end of src are preserved and copied to dst.
/// For example, if src has no trailing spaces, neither will dst;
/// if src ends in a trailing newline, so will dst.
pub fn Indent(
  dst: Ref<bytes.Buffer>,
  src: Slice<uint8>,
  prefix: string,
  indent: string,
) -> Result<(), error>

/// Marshal returns the JSON encoding of v.
/// 
/// Marshal traverses the value v recursively.
/// If an encountered value implements [Marshaler]
/// and is not a nil pointer, Marshal calls [Marshaler.MarshalJSON]
/// to produce JSON. If no [Marshaler.MarshalJSON] method is present but the
/// value implements [encoding.TextMarshaler] instead, Marshal calls
/// [encoding.TextMarshaler.MarshalText] and encodes the result as a JSON string.
/// The nil pointer exception is not strictly necessary
/// but mimics a similar, necessary exception in the behavior of
/// [Unmarshaler.UnmarshalJSON].
/// 
/// Otherwise, Marshal uses the following type-dependent default encodings:
/// 
/// Boolean values encode as JSON booleans.
/// 
/// Floating point, integer, and [Number] values encode as JSON numbers.
/// NaN and +/-Inf values will return an [UnsupportedValueError].
/// 
/// String values encode as JSON strings coerced to valid UTF-8,
/// replacing invalid bytes with the Unicode replacement rune.
/// So that the JSON will be safe to embed inside HTML <script> tags,
/// the string is encoded using [HTMLEscape],
/// which replaces "<", ">", "&", U+2028, and U+2029 are escaped
/// to "\u003c","\u003e", "\u0026", "\u2028", and "\u2029".
/// This replacement can be disabled when using an [Encoder],
/// by calling [Encoder.SetEscapeHTML](false).
/// 
/// Array and slice values encode as JSON arrays, except that
/// []byte encodes as a base64-encoded string, and a nil slice
/// encodes as the null JSON value.
/// 
/// Struct values encode as JSON objects.
/// Each exported struct field becomes a member of the object, using the
/// field name as the object key, unless the field is omitted for one of the
/// reasons given below.
/// 
/// The encoding of each struct field can be customized by the format string
/// stored under the "json" key in the struct field's tag.
/// The format string gives the name of the field, possibly followed by a
/// comma-separated list of options. The name may be empty in order to
/// specify options without overriding the default field name.
/// 
/// The "omitempty" option specifies that the field should be omitted
/// from the encoding if the field has an empty value, defined as
/// false, 0, a nil pointer, a nil interface value, and any array,
/// slice, map, or string of length zero.
/// 
/// As a special case, if the field tag is "-", the field is always omitted.
/// Note that a field with name "-" can still be generated using the tag "-,".
/// 
/// Examples of struct field tags and their meanings:
/// 
/// 	// Field appears in JSON as key "myName".
/// 	Field int `json:"myName"`
/// 
/// 	// Field appears in JSON as key "myName" and
/// 	// the field is omitted from the object if its value is empty,
/// 	// as defined above.
/// 	Field int `json:"myName,omitempty"`
/// 
/// 	// Field appears in JSON as key "Field" (the default), but
/// 	// the field is skipped if empty.
/// 	// Note the leading comma.
/// 	Field int `json:",omitempty"`
/// 
/// 	// Field is ignored by this package.
/// 	Field int `json:"-"`
/// 
/// 	// Field appears in JSON as key "-".
/// 	Field int `json:"-,"`
/// 
/// The "omitzero" option specifies that the field should be omitted
/// from the encoding if the field has a zero value, according to rules:
/// 
/// 1) If the field type has an "IsZero() bool" method, that will be used to
/// determine whether the value is zero.
/// 
/// 2) Otherwise, the value is zero if it is the zero value for its type.
/// 
/// If both "omitempty" and "omitzero" are specified, the field will be omitted
/// if the value is either empty or zero (or both).
/// 
/// The "string" option signals that a field is stored as JSON inside a
/// JSON-encoded string. It applies only to fields of string, floating point,
/// integer, or boolean types. This extra level of encoding is sometimes used
/// when communicating with JavaScript programs:
/// 
/// 	Int64String int64 `json:",string"`
/// 
/// The key name will be used if it's a non-empty string consisting of
/// only Unicode letters, digits, and ASCII punctuation except quotation
/// marks, backslash, and comma.
/// 
/// Embedded struct fields are usually marshaled as if their inner exported fields
/// were fields in the outer struct, subject to the usual Go visibility rules amended
/// as described in the next paragraph.
/// An anonymous struct field with a name given in its JSON tag is treated as
/// having that name, rather than being anonymous.
/// An anonymous struct field of interface type is treated the same as having
/// that type as its name, rather than being anonymous.
/// 
/// The Go visibility rules for struct fields are amended for JSON when
/// deciding which field to marshal or unmarshal. If there are
/// multiple fields at the same level, and that level is the least
/// nested (and would therefore be the nesting level selected by the
/// usual Go rules), the following extra rules apply:
/// 
/// 1) Of those fields, if any are JSON-tagged, only tagged fields are considered,
/// even if there are multiple untagged fields that would otherwise conflict.
/// 
/// 2) If there is exactly one field (tagged or not according to the first rule), that is selected.
/// 
/// 3) Otherwise there are multiple fields, and all are ignored; no error occurs.
/// 
/// Handling of anonymous struct fields is new in Go 1.1.
/// Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of
/// an anonymous struct field in both current and earlier versions, give the field
/// a JSON tag of "-".
/// 
/// Map values encode as JSON objects. The map's key type must either be a
/// string, an integer type, or implement [encoding.TextMarshaler]. The map keys
/// are sorted and used as JSON object keys by applying the following rules,
/// subject to the UTF-8 coercion described for string values above:
///   - keys of any string type are used directly
///   - keys that implement [encoding.TextMarshaler] are marshaled
///   - integer keys are converted to strings
/// 
/// Pointer values encode as the value pointed to.
/// A nil pointer encodes as the null JSON value.
/// 
/// Interface values encode as the value contained in the interface.
/// A nil interface value encodes as the null JSON value.
/// 
/// Channel, complex, and function values cannot be encoded in JSON.
/// Attempting to encode such a value causes Marshal to return
/// an [UnsupportedTypeError].
/// 
/// JSON cannot represent cyclic data structures and Marshal does not
/// handle them. Passing cyclic structures to Marshal will result in
/// an error.
pub fn Marshal(v: Unknown) -> Result<Slice<uint8>, error>

/// MarshalIndent is like [Marshal] but applies [Indent] to format the output.
/// Each JSON element in the output will begin on a new line beginning with prefix
/// followed by one or more copies of indent according to the indentation nesting.
pub fn MarshalIndent(v: Unknown, prefix: string, indent: string) -> Result<Slice<uint8>, error>

pub fn NewDecoder(r: io.Reader) -> Ref<Decoder>

pub fn NewEncoder(w: io.Writer) -> Ref<Encoder>

/// Unmarshal parses the JSON-encoded data and stores the result
/// in the value pointed to by v. If v is nil or not a pointer,
/// Unmarshal returns an [InvalidUnmarshalError].
/// 
/// Unmarshal uses the inverse of the encodings that
/// [Marshal] uses, allocating maps, slices, and pointers as necessary,
/// with the following additional rules:
/// 
/// To unmarshal JSON into a pointer, Unmarshal first handles the case of
/// the JSON being the JSON literal null. In that case, Unmarshal sets
/// the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
/// the value pointed at by the pointer. If the pointer is nil, Unmarshal
/// allocates a new value for it to point to.
/// 
/// To unmarshal JSON into a value implementing [Unmarshaler],
/// Unmarshal calls that value's [Unmarshaler.UnmarshalJSON] method, including
/// when the input is a JSON null.
/// Otherwise, if the value implements [encoding.TextUnmarshaler]
/// and the input is a JSON quoted string, Unmarshal calls
/// [encoding.TextUnmarshaler.UnmarshalText] with the unquoted form of the string.
/// 
/// To unmarshal JSON into a struct, Unmarshal matches incoming object keys to
/// the keys used by [Marshal] (either the struct field name or its tag),
/// ignoring case. If multiple struct fields match an object key, an exact case
/// match is preferred over a case-insensitive one.
/// 
/// Incoming object members are processed in the order observed. If an object
/// includes duplicate keys, later duplicates will replace or be merged into
/// prior values.
/// 
/// To unmarshal JSON into an interface value,
/// Unmarshal stores one of these in the interface value:
/// 
///   - bool, for JSON booleans
///   - float64, for JSON numbers
///   - string, for JSON strings
///   - []any, for JSON arrays
///   - map[string]any, for JSON objects
///   - nil for JSON null
/// 
/// To unmarshal a JSON array into a slice, Unmarshal resets the slice length
/// to zero and then appends each element to the slice.
/// As a special case, to unmarshal an empty JSON array into a slice,
/// Unmarshal replaces the slice with a new empty slice.
/// 
/// To unmarshal a JSON array into a Go array, Unmarshal decodes
/// JSON array elements into corresponding Go array elements.
/// If the Go array is smaller than the JSON array,
/// the additional JSON array elements are discarded.
/// If the JSON array is smaller than the Go array,
/// the additional Go array elements are set to zero values.
/// 
/// To unmarshal a JSON object into a map, Unmarshal first establishes a map to
/// use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal
/// reuses the existing map, keeping existing entries. Unmarshal then stores
/// key-value pairs from the JSON object into the map. The map's key type must
/// either be any string type, an integer, or implement [encoding.TextUnmarshaler].
/// 
/// If the JSON-encoded data contain a syntax error, Unmarshal returns a [SyntaxError].
/// 
/// If a JSON value is not appropriate for a given target type,
/// or if a JSON number overflows the target type, Unmarshal
/// skips that field and completes the unmarshaling as best it can.
/// If no more serious errors are encountered, Unmarshal returns
/// an [UnmarshalTypeError] describing the earliest such error. In any
/// case, it's not guaranteed that all the remaining fields following
/// the problematic one will be unmarshaled into the target object.
/// 
/// The JSON null value unmarshals into an interface, map, pointer, or slice
/// by setting that Go value to nil. Because null is often used in JSON to mean
/// “not present,” unmarshaling a JSON null into any other Go type has no effect
/// on the value and produces no error.
/// 
/// When unmarshaling quoted strings, invalid UTF-8 or
/// invalid UTF-16 surrogate pairs are not treated as an error.
/// Instead, they are replaced by the Unicode replacement
/// character U+FFFD.
pub fn Unmarshal<T>(data: Slice<uint8>, v: Ref<T>) -> Result<(), error>

/// Valid reports whether data is a valid JSON encoding.
pub fn Valid(data: Slice<uint8>) -> bool

/// A Decoder reads and decodes JSON values from an input stream.
pub type Decoder

/// A Delim is a JSON array or object delimiter, one of [ ] { or }.
pub struct Delim(int32)

/// An Encoder writes JSON values to an output stream.
pub type Encoder

/// Before Go 1.2, an InvalidUTF8Error was returned by [Marshal] when
/// attempting to encode a string value with invalid UTF-8 sequences.
/// As of Go 1.2, [Marshal] instead coerces the string to valid UTF-8 by
/// replacing invalid bytes with the Unicode replacement rune U+FFFD.
/// 
/// Deprecated: No longer used; kept for compatibility.
pub struct InvalidUTF8Error {
  pub S: string,
}

/// An InvalidUnmarshalError describes an invalid argument passed to [Unmarshal].
/// (The argument to [Unmarshal] must be a non-nil pointer.)
pub struct InvalidUnmarshalError {
  pub Type: Option<reflect.Type>,
}

/// Marshaler is the interface implemented by types that
/// can marshal themselves into valid JSON.
pub interface Marshaler {
  fn MarshalJSON() -> Result<Slice<uint8>, error>
}

/// A MarshalerError represents an error from calling a
/// [Marshaler.MarshalJSON] or [encoding.TextMarshaler.MarshalText] method.
pub struct MarshalerError {
  pub Type: Option<reflect.Type>,
  pub Err: error,
}

/// A Number represents a JSON number literal.
pub struct Number(string)

/// RawMessage is a raw encoded JSON value.
/// It implements [Marshaler] and [Unmarshaler] and can
/// be used to delay JSON decoding or precompute a JSON encoding.
pub struct RawMessage(Slice<uint8>)

/// A SyntaxError is a description of a JSON syntax error.
/// [Unmarshal] will return a SyntaxError if the JSON can't be parsed.
pub struct SyntaxError {
  pub Offset: int64,
}

/// A Token holds a value of one of these types:
/// 
///   - [Delim], for the four JSON delimiters [ ] { }
///   - bool, for JSON booleans
///   - float64, for JSON numbers
///   - [Number], for JSON numbers
///   - string, for JSON string literals
///   - nil, for JSON null
pub interface Token {}

/// An UnmarshalFieldError describes a JSON object key that
/// led to an unexported (and therefore unwritable) struct field.
/// 
/// Deprecated: No longer used; kept for compatibility.
pub struct UnmarshalFieldError {
  pub Key: string,
  pub Type: Option<reflect.Type>,
  pub Field: reflect.StructField,
}

/// An UnmarshalTypeError describes a JSON value that was
/// not appropriate for a value of a specific Go type.
pub struct UnmarshalTypeError {
  pub Value: string,
  pub Type: Option<reflect.Type>,
  pub Offset: int64,
  pub Struct: string,
  pub Field: string,
}

/// Unmarshaler is the interface implemented by types
/// that can unmarshal a JSON description of themselves.
/// The input can be assumed to be a valid encoding of
/// a JSON value. UnmarshalJSON must copy the JSON data
/// if it wishes to retain the data after returning.
pub interface Unmarshaler {
  fn UnmarshalJSON(arg0: Slice<uint8>) -> Result<(), error>
}

/// An UnsupportedTypeError is returned by [Marshal] when attempting
/// to encode an unsupported value type.
pub struct UnsupportedTypeError {
  pub Type: Option<reflect.Type>,
}

/// An UnsupportedValueError is returned by [Marshal] when attempting
/// to encode an unsupported value.
pub struct UnsupportedValueError {
  pub Value: reflect.Value,
  pub Str: string,
}

impl Decoder {
  /// Buffered returns a reader of the data remaining in the Decoder's
  /// buffer. The reader is valid until the next call to [Decoder.Decode].
  fn Buffered(self: Ref<Decoder>) -> io.Reader

  /// Decode reads the next JSON-encoded value from its
  /// input and stores it in the value pointed to by v.
  /// 
  /// See the documentation for [Unmarshal] for details about
  /// the conversion of JSON into a Go value.
  fn Decode<T>(self: Ref<Decoder>, v: Ref<T>) -> Result<(), error>

  /// DisallowUnknownFields causes the Decoder to return an error when the destination
  /// is a struct and the input contains object keys which do not match any
  /// non-ignored, exported fields in the destination.
  fn DisallowUnknownFields(self: Ref<Decoder>)

  /// InputOffset returns the input stream byte offset of the current decoder position.
  /// The offset gives the location of the end of the most recently returned token
  /// and the beginning of the next token.
  fn InputOffset(self: Ref<Decoder>) -> int64

  /// More reports whether there is another element in the
  /// current array or object being parsed.
  fn More(self: Ref<Decoder>) -> bool

  /// Token returns the next JSON token in the input stream.
  /// At the end of the input stream, Token returns nil, [io.EOF].
  /// 
  /// Token guarantees that the delimiters [ ] { } it returns are
  /// properly nested and matched: if Token encounters an unexpected
  /// delimiter in the input, it will return an error.
  /// 
  /// The input stream consists of basic JSON values—bool, string,
  /// number, and null—along with delimiters [ ] { } of type [Delim]
  /// to mark the start and end of arrays and objects.
  /// Commas and colons are elided.
  fn Token(self: Ref<Decoder>) -> Result<Token, error>

  /// UseNumber causes the Decoder to unmarshal a number into an
  /// interface value as a [Number] instead of as a float64.
  fn UseNumber(self: Ref<Decoder>)
}

impl Delim {
  fn String(self) -> string
}

impl Encoder {
  /// Encode writes the JSON encoding of v to the stream,
  /// with insignificant space characters elided,
  /// followed by a newline character.
  /// 
  /// See the documentation for [Marshal] for details about the
  /// conversion of Go values to JSON.
  fn Encode(self: Ref<Encoder>, v: Unknown) -> Result<(), error>

  /// SetEscapeHTML specifies whether problematic HTML characters
  /// should be escaped inside JSON quoted strings.
  /// The default behavior is to escape &, <, and > to \u0026, \u003c, and \u003e
  /// to avoid certain safety problems that can arise when embedding JSON in HTML.
  /// 
  /// In non-HTML settings where the escaping interferes with the readability
  /// of the output, SetEscapeHTML(false) disables this behavior.
  fn SetEscapeHTML(self: Ref<Encoder>, on: bool)

  /// SetIndent instructs the encoder to format each subsequent encoded
  /// value as if indented by the package-level function Indent(dst, src, prefix, indent).
  /// Calling SetIndent("", "") disables indentation.
  fn SetIndent(self: Ref<Encoder>, prefix: string, indent: string)
}

impl InvalidUTF8Error {
  fn Error(self: Ref<InvalidUTF8Error>) -> string
}

impl InvalidUnmarshalError {
  fn Error(self: Ref<InvalidUnmarshalError>) -> string
}

impl MarshalerError {
  fn Error(self: Ref<MarshalerError>) -> string

  /// Unwrap returns the underlying error.
  fn Unwrap(self: Ref<MarshalerError>) -> Option<error>
}

impl Number {
  /// Float64 returns the number as a float64.
  fn Float64(self) -> Result<float64, error>

  /// Int64 returns the number as an int64.
  fn Int64(self) -> Result<int64, error>

  /// String returns the literal text of the number.
  fn String(self) -> string
}

impl RawMessage {
  /// MarshalJSON returns m as the JSON encoding of m.
  fn MarshalJSON(self) -> Result<Slice<uint8>, error>

  /// UnmarshalJSON sets *m to a copy of data.
  fn UnmarshalJSON(self: Ref<RawMessage>, data: Slice<uint8>) -> Result<(), error>
}

impl SyntaxError {
  fn Error(self: Ref<SyntaxError>) -> string
}

impl UnmarshalFieldError {
  fn Error(self: Ref<UnmarshalFieldError>) -> string
}

impl UnmarshalTypeError {
  fn Error(self: Ref<UnmarshalTypeError>) -> string
}

impl UnsupportedTypeError {
  fn Error(self: Ref<UnsupportedTypeError>) -> string
}

impl UnsupportedValueError {
  fn Error(self: Ref<UnsupportedValueError>) -> string
}
