// Generated by Lisette bindgen
// Source: log (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1

import "go:io"

/// Default returns the standard logger used by the package-level output functions.
pub fn Default() -> Ref<Logger>

/// Fatal is equivalent to [Print] followed by a call to [os.Exit](1).
pub fn Fatal(v: VarArgs<Unknown>) -> Never

/// Fatalf is equivalent to [Printf] followed by a call to [os.Exit](1).
pub fn Fatalf(format: string, v: VarArgs<Unknown>) -> Never

/// Fatalln is equivalent to [Println] followed by a call to [os.Exit](1).
pub fn Fatalln(v: VarArgs<Unknown>) -> Never

/// Flags returns the output flags for the standard logger.
/// The flag bits are [Ldate], [Ltime], and so on.
pub fn Flags() -> int

/// New creates a new [Logger]. The out variable sets the
/// destination to which log data will be written.
/// The prefix appears at the beginning of each generated log line, or
/// after the log header if the [Lmsgprefix] flag is provided.
/// The flag argument defines the logging properties.
pub fn New(out: io.Writer, prefix: string, flag: int) -> Ref<Logger>

/// Output writes the output for a logging event. The string s contains
/// the text to print after the prefix specified by the flags of the
/// Logger. A newline is appended if the last character of s is not
/// already a newline. Calldepth is the count of the number of
/// frames to skip when computing the file name and line number
/// if [Llongfile] or [Lshortfile] is set; a value of 1 will print the details
/// for the caller of Output.
pub fn Output(calldepth: int, s: string) -> Result<(), error>

/// Panic is equivalent to [Print] followed by a call to panic().
pub fn Panic(v: VarArgs<Unknown>)

/// Panicf is equivalent to [Printf] followed by a call to panic().
pub fn Panicf(format: string, v: VarArgs<Unknown>)

/// Panicln is equivalent to [Println] followed by a call to panic().
pub fn Panicln(v: VarArgs<Unknown>)

/// Prefix returns the output prefix for the standard logger.
pub fn Prefix() -> string

/// Print calls Output to print to the standard logger.
/// Arguments are handled in the manner of [fmt.Print].
pub fn Print(v: VarArgs<Unknown>)

/// Printf calls Output to print to the standard logger.
/// Arguments are handled in the manner of [fmt.Printf].
pub fn Printf(format: string, v: VarArgs<Unknown>)

/// Println calls Output to print to the standard logger.
/// Arguments are handled in the manner of [fmt.Println].
pub fn Println(v: VarArgs<Unknown>)

/// SetFlags sets the output flags for the standard logger.
/// The flag bits are [Ldate], [Ltime], and so on.
pub fn SetFlags(flag: int)

/// SetOutput sets the output destination for the standard logger.
pub fn SetOutput(w: io.Writer)

/// SetPrefix sets the output prefix for the standard logger.
pub fn SetPrefix(prefix: string)

/// Writer returns the output destination for the standard logger.
pub fn Writer() -> io.Writer

/// A Logger represents an active logging object that generates lines of
/// output to an [io.Writer]. Each logging operation makes a single call to
/// the Writer's Write method. A Logger can be used simultaneously from
/// multiple goroutines; it guarantees to serialize access to the Writer.
pub type Logger

/// These flags define which text to prefix to each log entry generated by the [Logger].
/// Bits are or'ed together to control what's printed.
/// With the exception of the Lmsgprefix flag, there is no
/// control over the order they appear (the order listed here)
/// or the format they present (as described in the comments).
/// The prefix is followed by a colon only when Llongfile or Lshortfile
/// is specified.
/// For example, flags Ldate | Ltime (or LstdFlags) produce,
/// 
/// 	2009/01/23 01:23:23 message
/// 
/// while flags Ldate | Ltime | Lmicroseconds | Llongfile produce,
/// 
/// 	2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
pub const LUTC = 32

/// These flags define which text to prefix to each log entry generated by the [Logger].
/// Bits are or'ed together to control what's printed.
/// With the exception of the Lmsgprefix flag, there is no
/// control over the order they appear (the order listed here)
/// or the format they present (as described in the comments).
/// The prefix is followed by a colon only when Llongfile or Lshortfile
/// is specified.
/// For example, flags Ldate | Ltime (or LstdFlags) produce,
/// 
/// 	2009/01/23 01:23:23 message
/// 
/// while flags Ldate | Ltime | Lmicroseconds | Llongfile produce,
/// 
/// 	2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
pub const Ldate = 1

/// These flags define which text to prefix to each log entry generated by the [Logger].
/// Bits are or'ed together to control what's printed.
/// With the exception of the Lmsgprefix flag, there is no
/// control over the order they appear (the order listed here)
/// or the format they present (as described in the comments).
/// The prefix is followed by a colon only when Llongfile or Lshortfile
/// is specified.
/// For example, flags Ldate | Ltime (or LstdFlags) produce,
/// 
/// 	2009/01/23 01:23:23 message
/// 
/// while flags Ldate | Ltime | Lmicroseconds | Llongfile produce,
/// 
/// 	2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
pub const Llongfile = 8

/// These flags define which text to prefix to each log entry generated by the [Logger].
/// Bits are or'ed together to control what's printed.
/// With the exception of the Lmsgprefix flag, there is no
/// control over the order they appear (the order listed here)
/// or the format they present (as described in the comments).
/// The prefix is followed by a colon only when Llongfile or Lshortfile
/// is specified.
/// For example, flags Ldate | Ltime (or LstdFlags) produce,
/// 
/// 	2009/01/23 01:23:23 message
/// 
/// while flags Ldate | Ltime | Lmicroseconds | Llongfile produce,
/// 
/// 	2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
pub const Lmicroseconds = 4

/// These flags define which text to prefix to each log entry generated by the [Logger].
/// Bits are or'ed together to control what's printed.
/// With the exception of the Lmsgprefix flag, there is no
/// control over the order they appear (the order listed here)
/// or the format they present (as described in the comments).
/// The prefix is followed by a colon only when Llongfile or Lshortfile
/// is specified.
/// For example, flags Ldate | Ltime (or LstdFlags) produce,
/// 
/// 	2009/01/23 01:23:23 message
/// 
/// while flags Ldate | Ltime | Lmicroseconds | Llongfile produce,
/// 
/// 	2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
pub const Lmsgprefix = 64

/// These flags define which text to prefix to each log entry generated by the [Logger].
/// Bits are or'ed together to control what's printed.
/// With the exception of the Lmsgprefix flag, there is no
/// control over the order they appear (the order listed here)
/// or the format they present (as described in the comments).
/// The prefix is followed by a colon only when Llongfile or Lshortfile
/// is specified.
/// For example, flags Ldate | Ltime (or LstdFlags) produce,
/// 
/// 	2009/01/23 01:23:23 message
/// 
/// while flags Ldate | Ltime | Lmicroseconds | Llongfile produce,
/// 
/// 	2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
pub const Lshortfile = 16

/// These flags define which text to prefix to each log entry generated by the [Logger].
/// Bits are or'ed together to control what's printed.
/// With the exception of the Lmsgprefix flag, there is no
/// control over the order they appear (the order listed here)
/// or the format they present (as described in the comments).
/// The prefix is followed by a colon only when Llongfile or Lshortfile
/// is specified.
/// For example, flags Ldate | Ltime (or LstdFlags) produce,
/// 
/// 	2009/01/23 01:23:23 message
/// 
/// while flags Ldate | Ltime | Lmicroseconds | Llongfile produce,
/// 
/// 	2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
pub const LstdFlags = 3

/// These flags define which text to prefix to each log entry generated by the [Logger].
/// Bits are or'ed together to control what's printed.
/// With the exception of the Lmsgprefix flag, there is no
/// control over the order they appear (the order listed here)
/// or the format they present (as described in the comments).
/// The prefix is followed by a colon only when Llongfile or Lshortfile
/// is specified.
/// For example, flags Ldate | Ltime (or LstdFlags) produce,
/// 
/// 	2009/01/23 01:23:23 message
/// 
/// while flags Ldate | Ltime | Lmicroseconds | Llongfile produce,
/// 
/// 	2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
pub const Ltime = 2

impl Logger {
  /// Fatal is equivalent to l.Print() followed by a call to [os.Exit](1).
  fn Fatal(self: Ref<Logger>, v: VarArgs<Unknown>) -> Never

  /// Fatalf is equivalent to l.Printf() followed by a call to [os.Exit](1).
  fn Fatalf(self: Ref<Logger>, format: string, v: VarArgs<Unknown>) -> Never

  /// Fatalln is equivalent to l.Println() followed by a call to [os.Exit](1).
  fn Fatalln(self: Ref<Logger>, v: VarArgs<Unknown>) -> Never

  /// Flags returns the output flags for the logger.
  /// The flag bits are [Ldate], [Ltime], and so on.
  fn Flags(self: Ref<Logger>) -> int

  /// Output writes the output for a logging event. The string s contains
  /// the text to print after the prefix specified by the flags of the
  /// Logger. A newline is appended if the last character of s is not
  /// already a newline. Calldepth is used to recover the PC and is
  /// provided for generality, although at the moment on all pre-defined
  /// paths it will be 2.
  fn Output(self: Ref<Logger>, calldepth: int, s: string) -> Result<(), error>

  /// Panic is equivalent to l.Print() followed by a call to panic().
  fn Panic(self: Ref<Logger>, v: VarArgs<Unknown>)

  /// Panicf is equivalent to l.Printf() followed by a call to panic().
  fn Panicf(self: Ref<Logger>, format: string, v: VarArgs<Unknown>)

  /// Panicln is equivalent to l.Println() followed by a call to panic().
  fn Panicln(self: Ref<Logger>, v: VarArgs<Unknown>)

  /// Prefix returns the output prefix for the logger.
  fn Prefix(self: Ref<Logger>) -> string

  /// Print calls l.Output to print to the logger.
  /// Arguments are handled in the manner of [fmt.Print].
  fn Print(self: Ref<Logger>, v: VarArgs<Unknown>)

  /// Printf calls l.Output to print to the logger.
  /// Arguments are handled in the manner of [fmt.Printf].
  fn Printf(self: Ref<Logger>, format: string, v: VarArgs<Unknown>)

  /// Println calls l.Output to print to the logger.
  /// Arguments are handled in the manner of [fmt.Println].
  fn Println(self: Ref<Logger>, v: VarArgs<Unknown>)

  /// SetFlags sets the output flags for the logger.
  /// The flag bits are [Ldate], [Ltime], and so on.
  fn SetFlags(self: Ref<Logger>, flag: int)

  /// SetOutput sets the output destination for the logger.
  fn SetOutput(self: Ref<Logger>, w: io.Writer)

  /// SetPrefix sets the output prefix for the logger.
  fn SetPrefix(self: Ref<Logger>, prefix: string)

  /// Writer returns the output destination for the logger.
  fn Writer(self: Ref<Logger>) -> io.Writer
}
