/**
     * {@return true if the <b>warn</b> error level is enabled}
     */
    boolean isWarnEnabled();

    /**
     * Sends a message to the user in the <b>warn</b> error level.
     *
     * @param content the message to log
     */
    void warn(CharSequence content);

    /**
     * Sends a message (and accompanying exception) to the user in the <b>warn</b> error level.

     */
    public boolean isInfoEnabled() {
        return INFO.equals(logLevel);
    }

    /**
     * Checks if the log level is WARN.
     *
     * @return true if WARN, false otherwise
     */
    public boolean isWarnEnabled() {
        return WARN.equals(logLevel);
    }

    /**
     * Checks if the log level is ERROR.
     * @return true if ERROR, false otherwise.
     */

import okhttp3.CookieJar
import okhttp3.HttpUrl
import okhttp3.internal.cookieToString
import okhttp3.internal.delimiterOffset
import okhttp3.internal.platform.Platform
import okhttp3.internal.platform.Platform.Companion.WARN
import okhttp3.internal.trimSubstring

/** A cookie jar that delegates to a [java.net.CookieHandler]. */
class JavaNetCookieJar(
  private val cookieHandler: CookieHandler,
) : CookieJar {

	return S.Logger.LogMode(level)
}

func (S Tracer) Info(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Info(ctx, s, i...)
}

func (S Tracer) Warn(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Warn(ctx, s, i...)
}

func (S Tracer) Error(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Error(ctx, s, i...)
}

	if l.LogLevel >= Info {
		l.Printf(l.infoStr+msg, append([]interface{}{utils.FileWithLineNum()}, data...)...)
	}
}

// Warn print warn messages
func (l *logger) Warn(ctx context.Context, msg string, data ...interface{}) {
	if l.LogLevel >= Warn {
		l.Printf(l.warnStr+msg, append([]interface{}{utils.FileWithLineNum()}, data...)...)
	}
}

// Error print error messages

    boolean isErrorEnabled();

    void error(String message);

    void error(String message, Throwable t);

    boolean isWarnEnabled();

    void warn(String message);

    void warn(String message, Throwable t);

    boolean isInfoEnabled();

    void info(String message);

    void info(String message, Throwable t);

    boolean isDebugEnabled();

    @Override
    public boolean isWarnEnabled() {
        return logger.isWarnEnabled();
    }

    @Override
    public void warn(final String message) {
        logger.warn(message);
    }

    @Override
    public void warn(final String message, final Throwable t) {
        logger.warn(message, t);
    }

    @Override
    public boolean isInfoEnabled() {
        return logger.isInfoEnabled();
    }

    /** Array of logger name prefixes to apply the ERROR to WARN conversion */
    private final String[] loggerNames;

    /**
     * Constructs a new ErrorToWarnRewritePolicy with the specified logger names.
     *
     * @param loggerNames array of logger name prefixes to convert ERROR to WARN
     */
    public ErrorToWarnRewritePolicy(final String[] loggerNames) {

                    }
                } else {
                    logger.warn("Failed to send {} to {}. HTTP Status is {}. {}", body, url, response.getHttpStatusCode(),
                            response.getContentAsString());
                }
            } catch (final IOException e) {
                logger.warn("Failed to send {} to {}.", body, url, e);
            }
        }));
    }

    /**

	if l.LogLevel >= Info {
		l.Logger.InfoContext(ctx, msg, slog.Any("data", data))
	}
}

func (l *slogLogger) Warn(ctx context.Context, msg string, data ...interface{}) {
	if l.LogLevel >= Warn {
		l.Logger.WarnContext(ctx, msg, slog.Any("data", data))
	}
}

func (l *slogLogger) Error(ctx context.Context, msg string, data ...interface{}) {
	if l.LogLevel >= Error {