// 
// Decompiled by Procyon v0.6.0
// 

package io.sentry;

import io.sentry.logger.ILoggerApi;
import io.sentry.transport.RateLimiter;
import io.sentry.protocol.SentryTransaction;
import java.util.List;
import io.sentry.protocol.User;
import org.jetbrains.annotations.ApiStatus;
import io.sentry.protocol.Feedback;
import io.sentry.protocol.SentryId;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.NotNull;

@Deprecated
public final class HubAdapter implements IHub
{
    private static final HubAdapter INSTANCE;
    
    private HubAdapter() {
    }
    
    public static HubAdapter getInstance() {
        return HubAdapter.INSTANCE;
    }
    
    @Override
    public boolean isEnabled() {
        return Sentry.isEnabled();
    }
    
    @NotNull
    @Override
    public SentryId captureEvent(@NotNull final SentryEvent event, @Nullable final Hint hint) {
        return Sentry.captureEvent(event, hint);
    }
    
    @NotNull
    @Override
    public SentryId captureEvent(@NotNull final SentryEvent event, @Nullable final Hint hint, @NotNull final ScopeCallback callback) {
        return Sentry.captureEvent(event, hint, callback);
    }
    
    @NotNull
    @Override
    public SentryId captureMessage(@NotNull final String message, @NotNull final SentryLevel level) {
        return Sentry.captureMessage(message, level);
    }
    
    @NotNull
    @Override
    public SentryId captureMessage(@NotNull final String message, @NotNull final SentryLevel level, @NotNull final ScopeCallback callback) {
        return Sentry.captureMessage(message, level, callback);
    }
    
    @NotNull
    @Override
    public SentryId captureFeedback(@NotNull final Feedback feedback) {
        return Sentry.captureFeedback(feedback);
    }
    
    @NotNull
    @Override
    public SentryId captureFeedback(@NotNull final Feedback feedback, @Nullable final Hint hint) {
        return Sentry.captureFeedback(feedback, hint);
    }
    
    @NotNull
    @Override
    public SentryId captureFeedback(@NotNull final Feedback feedback, @Nullable final Hint hint, @Nullable final ScopeCallback callback) {
        return Sentry.captureFeedback(feedback, hint, callback);
    }
    
    @ApiStatus.Internal
    @NotNull
    @Override
    public SentryId captureEnvelope(@NotNull final SentryEnvelope envelope, @Nullable final Hint hint) {
        return Sentry.getCurrentScopes().captureEnvelope(envelope, hint);
    }
    
    @NotNull
    @Override
    public SentryId captureException(@NotNull final Throwable throwable, @Nullable final Hint hint) {
        return Sentry.captureException(throwable, hint);
    }
    
    @NotNull
    @Override
    public SentryId captureException(@NotNull final Throwable throwable, @Nullable final Hint hint, @NotNull final ScopeCallback callback) {
        return Sentry.captureException(throwable, hint, callback);
    }
    
    @Override
    public void captureUserFeedback(@NotNull final UserFeedback userFeedback) {
        Sentry.captureUserFeedback(userFeedback);
    }
    
    @Override
    public void startSession() {
        Sentry.startSession();
    }
    
    @Override
    public void endSession() {
        Sentry.endSession();
    }
    
    @Override
    public void close(final boolean isRestarting) {
        Sentry.close();
    }
    
    @Override
    public void close() {
        Sentry.close();
    }
    
    @Override
    public void addBreadcrumb(@NotNull final Breadcrumb breadcrumb, @Nullable final Hint hint) {
        Sentry.addBreadcrumb(breadcrumb, hint);
    }
    
    @Override
    public void addBreadcrumb(@NotNull final Breadcrumb breadcrumb) {
        this.addBreadcrumb(breadcrumb, new Hint());
    }
    
    @Override
    public void setLevel(@Nullable final SentryLevel level) {
        Sentry.setLevel(level);
    }
    
    @Override
    public void setTransaction(@Nullable final String transaction) {
        Sentry.setTransaction(transaction);
    }
    
    @Override
    public void setUser(@Nullable final User user) {
        Sentry.setUser(user);
    }
    
    @Override
    public void setFingerprint(@NotNull final List<String> fingerprint) {
        Sentry.setFingerprint(fingerprint);
    }
    
    @Override
    public void clearBreadcrumbs() {
        Sentry.clearBreadcrumbs();
    }
    
    @Override
    public void setTag(@Nullable final String key, @Nullable final String value) {
        Sentry.setTag(key, value);
    }
    
    @Override
    public void removeTag(@Nullable final String key) {
        Sentry.removeTag(key);
    }
    
    @Override
    public void setExtra(@Nullable final String key, @Nullable final String value) {
        Sentry.setExtra(key, value);
    }
    
    @Override
    public void removeExtra(@Nullable final String key) {
        Sentry.removeExtra(key);
    }
    
    @NotNull
    @Override
    public SentryId getLastEventId() {
        return Sentry.getLastEventId();
    }
    
    @NotNull
    @Override
    public ISentryLifecycleToken pushScope() {
        return Sentry.pushScope();
    }
    
    @NotNull
    @Override
    public ISentryLifecycleToken pushIsolationScope() {
        return Sentry.pushIsolationScope();
    }
    
    @Deprecated
    @Override
    public void popScope() {
        Sentry.popScope();
    }
    
    @Override
    public void withScope(@NotNull final ScopeCallback callback) {
        Sentry.withScope(callback);
    }
    
    @Override
    public void withIsolationScope(@NotNull final ScopeCallback callback) {
        Sentry.withIsolationScope(callback);
    }
    
    @Override
    public void configureScope(@Nullable final ScopeType scopeType, @NotNull final ScopeCallback callback) {
        Sentry.configureScope(scopeType, callback);
    }
    
    @Override
    public void bindClient(@NotNull final ISentryClient client) {
        Sentry.bindClient(client);
    }
    
    @Override
    public boolean isHealthy() {
        return Sentry.isHealthy();
    }
    
    @Override
    public void flush(final long timeoutMillis) {
        Sentry.flush(timeoutMillis);
    }
    
    @Deprecated
    @NotNull
    @Override
    public IHub clone() {
        return Sentry.getCurrentScopes().clone();
    }
    
    @NotNull
    @Override
    public IScopes forkedScopes(@NotNull final String creator) {
        return Sentry.forkedScopes(creator);
    }
    
    @NotNull
    @Override
    public IScopes forkedCurrentScope(@NotNull final String creator) {
        return Sentry.forkedCurrentScope(creator);
    }
    
    @NotNull
    @Override
    public IScopes forkedRootScopes(@NotNull final String creator) {
        return Sentry.forkedRootScopes(creator);
    }
    
    @NotNull
    @Override
    public ISentryLifecycleToken makeCurrent() {
        return NoOpScopesLifecycleToken.getInstance();
    }
    
    @ApiStatus.Internal
    @NotNull
    @Override
    public IScope getScope() {
        return Sentry.getCurrentScopes().getScope();
    }
    
    @ApiStatus.Internal
    @NotNull
    @Override
    public IScope getIsolationScope() {
        return Sentry.getCurrentScopes().getIsolationScope();
    }
    
    @ApiStatus.Internal
    @NotNull
    @Override
    public IScope getGlobalScope() {
        return Sentry.getGlobalScope();
    }
    
    @Nullable
    @Override
    public IScopes getParentScopes() {
        return Sentry.getCurrentScopes().getParentScopes();
    }
    
    @Override
    public boolean isAncestorOf(@Nullable final IScopes otherScopes) {
        return Sentry.getCurrentScopes().isAncestorOf(otherScopes);
    }
    
    @NotNull
    @Override
    public SentryId captureTransaction(@NotNull final SentryTransaction transaction, @Nullable final TraceContext traceContext, @Nullable final Hint hint, @Nullable final ProfilingTraceData profilingTraceData) {
        return Sentry.getCurrentScopes().captureTransaction(transaction, traceContext, hint, profilingTraceData);
    }
    
    @NotNull
    @Override
    public ITransaction startTransaction(@NotNull final TransactionContext transactionContext, @NotNull final TransactionOptions transactionOptions) {
        return Sentry.startTransaction(transactionContext, transactionOptions);
    }
    
    @Override
    public void startProfiler() {
        Sentry.startProfiler();
    }
    
    @Override
    public void stopProfiler() {
        Sentry.stopProfiler();
    }
    
    @NotNull
    @Override
    public SentryId captureProfileChunk(@NotNull final ProfileChunk profilingContinuousData) {
        return Sentry.getCurrentScopes().captureProfileChunk(profilingContinuousData);
    }
    
    @Override
    public void setSpanContext(@NotNull final Throwable throwable, @NotNull final ISpan span, @NotNull final String transactionName) {
        Sentry.getCurrentScopes().setSpanContext(throwable, span, transactionName);
    }
    
    @Nullable
    @Override
    public ISpan getSpan() {
        return Sentry.getCurrentScopes().getSpan();
    }
    
    @Override
    public void setActiveSpan(@Nullable final ISpan span) {
        Sentry.getCurrentScopes().setActiveSpan(span);
    }
    
    @ApiStatus.Internal
    @Nullable
    @Override
    public ITransaction getTransaction() {
        return Sentry.getCurrentScopes().getTransaction();
    }
    
    @NotNull
    @Override
    public SentryOptions getOptions() {
        return Sentry.getCurrentScopes().getOptions();
    }
    
    @Nullable
    @Override
    public Boolean isCrashedLastRun() {
        return Sentry.isCrashedLastRun();
    }
    
    @Override
    public void reportFullyDisplayed() {
        Sentry.reportFullyDisplayed();
    }
    
    @Nullable
    @Override
    public TransactionContext continueTrace(@Nullable final String sentryTrace, @Nullable final List<String> baggageHeaders) {
        return Sentry.continueTrace(sentryTrace, baggageHeaders);
    }
    
    @Nullable
    @Override
    public SentryTraceHeader getTraceparent() {
        return Sentry.getTraceparent();
    }
    
    @Nullable
    @Override
    public BaggageHeader getBaggage() {
        return Sentry.getBaggage();
    }
    
    @ApiStatus.Experimental
    @NotNull
    @Override
    public SentryId captureCheckIn(@NotNull final CheckIn checkIn) {
        return Sentry.captureCheckIn(checkIn);
    }
    
    @NotNull
    @Override
    public SentryId captureReplay(@NotNull final SentryReplayEvent replay, @Nullable final Hint hint) {
        return Sentry.getCurrentScopes().captureReplay(replay, hint);
    }
    
    @ApiStatus.Internal
    @Nullable
    @Override
    public RateLimiter getRateLimiter() {
        return Sentry.getCurrentScopes().getRateLimiter();
    }
    
    @NotNull
    @Override
    public ILoggerApi logger() {
        return Sentry.getCurrentScopes().logger();
    }
    
    @Override
    public void addFeatureFlag(@Nullable final String flag, @Nullable final Boolean result) {
        Sentry.addFeatureFlag(flag, result);
    }
    
    static {
        INSTANCE = new HubAdapter();
    }
}