// Generated by Lisette bindgen
// Source: encoding/json (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.14
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(data: Slice<uint8>, v: Unknown) -> 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(self: Ref<Decoder>, v: Unknown) -> 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
}