Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideApplicationObserverFactory.java

@@ -0,0 +1,41 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.observers.ApplicationObserver;
+import com.adif.elcanomovil.observers.LoggerObserver;
+import com.adif.elcanomovil.observers.RemoteConfigurationObserver;
+import com.adif.elcanomovil.observers.UpdateStationsObserver;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideApplicationObserverFactory implements Factory<ApplicationObserver> {
+    private final Provider<LoggerObserver> loggerObserverProvider;
+    private final Provider<RemoteConfigurationObserver> remoteConfigurationObserverProvider;
+    private final Provider<UpdateStationsObserver> updateStationsObserverProvider;
+
+    public ApplicationModule_Companion_ProvideApplicationObserverFactory(Provider<LoggerObserver> provider, Provider<RemoteConfigurationObserver> provider2, Provider<UpdateStationsObserver> provider3) {
+        this.loggerObserverProvider = provider;
+        this.remoteConfigurationObserverProvider = provider2;
+        this.updateStationsObserverProvider = provider3;
+    }
+
+    public static ApplicationModule_Companion_ProvideApplicationObserverFactory create(Provider<LoggerObserver> provider, Provider<RemoteConfigurationObserver> provider2, Provider<UpdateStationsObserver> provider3) {
+        return new ApplicationModule_Companion_ProvideApplicationObserverFactory(provider, provider2, provider3);
+    }
+
+    public static ApplicationObserver provideApplicationObserver(LoggerObserver loggerObserver, RemoteConfigurationObserver remoteConfigurationObserver, UpdateStationsObserver updateStationsObserver) {
+        return (ApplicationObserver) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideApplicationObserver(loggerObserver, remoteConfigurationObserver, updateStationsObserver));
+    }
+
+    @Override // javax.inject.Provider
+    public ApplicationObserver get() {
+        return provideApplicationObserver(this.loggerObserverProvider.get(), this.remoteConfigurationObserverProvider.get(), this.updateStationsObserverProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideAuthtenticationProviderFactory.java

@@ -0,0 +1,44 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.usecases.avisa.user.LoginAvisaUserUseCase;
+import com.adif.elcanomovil.domain.usecases.avisa.user.RefreshAvisaUserUseCase;
+import com.adif.elcanomovil.domain.usecases.avisa.user.RegisterAvisaUserUseCase;
+import com.adif.elcanomovil.serviceStorage.preferences.PreferenceStorage;
+import com.adif.elcanomovil.uiAvisa.components.authenticator.AuthenticationProvider;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideAuthtenticationProviderFactory implements Factory<AuthenticationProvider> {
+    private final Provider<LoginAvisaUserUseCase> loginAvisaUserUseCaseProvider;
+    private final Provider<PreferenceStorage> preferenceStorageProvider;
+    private final Provider<RefreshAvisaUserUseCase> refreshAvisaUserUseCaseProvider;
+    private final Provider<RegisterAvisaUserUseCase> registerAvisaUserUseCaseProvider;
+
+    public ApplicationModule_Companion_ProvideAuthtenticationProviderFactory(Provider<RegisterAvisaUserUseCase> provider, Provider<LoginAvisaUserUseCase> provider2, Provider<RefreshAvisaUserUseCase> provider3, Provider<PreferenceStorage> provider4) {
+        this.registerAvisaUserUseCaseProvider = provider;
+        this.loginAvisaUserUseCaseProvider = provider2;
+        this.refreshAvisaUserUseCaseProvider = provider3;
+        this.preferenceStorageProvider = provider4;
+    }
+
+    public static ApplicationModule_Companion_ProvideAuthtenticationProviderFactory create(Provider<RegisterAvisaUserUseCase> provider, Provider<LoginAvisaUserUseCase> provider2, Provider<RefreshAvisaUserUseCase> provider3, Provider<PreferenceStorage> provider4) {
+        return new ApplicationModule_Companion_ProvideAuthtenticationProviderFactory(provider, provider2, provider3, provider4);
+    }
+
+    public static AuthenticationProvider provideAuthtenticationProvider(RegisterAvisaUserUseCase registerAvisaUserUseCase, LoginAvisaUserUseCase loginAvisaUserUseCase, RefreshAvisaUserUseCase refreshAvisaUserUseCase, PreferenceStorage preferenceStorage) {
+        return (AuthenticationProvider) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideAuthtenticationProvider(registerAvisaUserUseCase, loginAvisaUserUseCase, refreshAvisaUserUseCase, preferenceStorage));
+    }
+
+    @Override // javax.inject.Provider
+    public AuthenticationProvider get() {
+        return provideAuthtenticationProvider(this.registerAvisaUserUseCaseProvider.get(), this.loginAvisaUserUseCaseProvider.get(), this.refreshAvisaUserUseCaseProvider.get(), this.preferenceStorageProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideFirebaseCrashlyticsFactory.java

@@ -0,0 +1,28 @@
+package com.adif.elcanomovil.di;
+
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import g1.AbstractC0374a;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideFirebaseCrashlyticsFactory implements Factory<FirebaseCrashlytics> {
+    public static ApplicationModule_Companion_ProvideFirebaseCrashlyticsFactory create() {
+        return AbstractC0374a.f6736a;
+    }
+
+    public static FirebaseCrashlytics provideFirebaseCrashlytics() {
+        return (FirebaseCrashlytics) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideFirebaseCrashlytics());
+    }
+
+    @Override // javax.inject.Provider
+    public FirebaseCrashlytics get() {
+        return provideFirebaseCrashlytics();
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideFirebaseMessagingFactory.java

@@ -0,0 +1,28 @@
+package com.adif.elcanomovil.di;
+
+import com.google.firebase.messaging.FirebaseMessaging;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import g1.AbstractC0375b;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideFirebaseMessagingFactory implements Factory<FirebaseMessaging> {
+    public static ApplicationModule_Companion_ProvideFirebaseMessagingFactory create() {
+        return AbstractC0375b.f6737a;
+    }
+
+    public static FirebaseMessaging provideFirebaseMessaging() {
+        return (FirebaseMessaging) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideFirebaseMessaging());
+    }
+
+    @Override // javax.inject.Provider
+    public FirebaseMessaging get() {
+        return provideFirebaseMessaging();
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideLifeCicleProviderFactory.java

@@ -0,0 +1,28 @@
+package com.adif.elcanomovil.di;
+
+import androidx.lifecycle.I;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import g1.AbstractC0376c;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideLifeCicleProviderFactory implements Factory<I> {
+    public static ApplicationModule_Companion_ProvideLifeCicleProviderFactory create() {
+        return AbstractC0376c.f6738a;
+    }
+
+    public static I provideLifeCicleProvider() {
+        return (I) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideLifeCicleProvider());
+    }
+
+    @Override // javax.inject.Provider
+    public I get() {
+        return provideLifeCicleProvider();
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideLoggerObserverFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.observers.LoggerObserver;
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideLoggerObserverFactory implements Factory<LoggerObserver> {
+    private final Provider<FirebaseCrashlytics> firebaseCrashlyticsProvider;
+
+    public ApplicationModule_Companion_ProvideLoggerObserverFactory(Provider<FirebaseCrashlytics> provider) {
+        this.firebaseCrashlyticsProvider = provider;
+    }
+
+    public static ApplicationModule_Companion_ProvideLoggerObserverFactory create(Provider<FirebaseCrashlytics> provider) {
+        return new ApplicationModule_Companion_ProvideLoggerObserverFactory(provider);
+    }
+
+    public static LoggerObserver provideLoggerObserver(FirebaseCrashlytics firebaseCrashlytics) {
+        return (LoggerObserver) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideLoggerObserver(firebaseCrashlytics));
+    }
+
+    @Override // javax.inject.Provider
+    public LoggerObserver get() {
+        return provideLoggerObserver(this.firebaseCrashlyticsProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideNotificationPayloadHandlerFactory.java

@@ -0,0 +1,28 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.notifications.NotificationPayloadHandler;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import g1.d;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideNotificationPayloadHandlerFactory implements Factory<NotificationPayloadHandler> {
+    public static ApplicationModule_Companion_ProvideNotificationPayloadHandlerFactory create() {
+        return d.f6739a;
+    }
+
+    public static NotificationPayloadHandler provideNotificationPayloadHandler() {
+        return (NotificationPayloadHandler) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideNotificationPayloadHandler());
+    }
+
+    @Override // javax.inject.Provider
+    public NotificationPayloadHandler get() {
+        return provideNotificationPayloadHandler();
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideRemoteConfigurationObserverFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.usecases.FetchVersionUpdateUseCase;
+import com.adif.elcanomovil.observers.RemoteConfigurationObserver;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideRemoteConfigurationObserverFactory implements Factory<RemoteConfigurationObserver> {
+    private final Provider<FetchVersionUpdateUseCase> fetchVersionUpdateUseCaseProvider;
+
+    public ApplicationModule_Companion_ProvideRemoteConfigurationObserverFactory(Provider<FetchVersionUpdateUseCase> provider) {
+        this.fetchVersionUpdateUseCaseProvider = provider;
+    }
+
+    public static ApplicationModule_Companion_ProvideRemoteConfigurationObserverFactory create(Provider<FetchVersionUpdateUseCase> provider) {
+        return new ApplicationModule_Companion_ProvideRemoteConfigurationObserverFactory(provider);
+    }
+
+    public static RemoteConfigurationObserver provideRemoteConfigurationObserver(FetchVersionUpdateUseCase fetchVersionUpdateUseCase) {
+        return (RemoteConfigurationObserver) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideRemoteConfigurationObserver(fetchVersionUpdateUseCase));
+    }
+
+    @Override // javax.inject.Provider
+    public RemoteConfigurationObserver get() {
+        return provideRemoteConfigurationObserver(this.fetchVersionUpdateUseCaseProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideStringProviderFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import android.content.Context;
+import d1.g;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata({"dagger.hilt.android.qualifiers.ApplicationContext"})
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideStringProviderFactory implements Factory<g> {
+    private final Provider<Context> contextProvider;
+
+    public ApplicationModule_Companion_ProvideStringProviderFactory(Provider<Context> provider) {
+        this.contextProvider = provider;
+    }
+
+    public static ApplicationModule_Companion_ProvideStringProviderFactory create(Provider<Context> provider) {
+        return new ApplicationModule_Companion_ProvideStringProviderFactory(provider);
+    }
+
+    public static g provideStringProvider(Context context) {
+        return (g) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideStringProvider(context));
+    }
+
+    @Override // javax.inject.Provider
+    public g get() {
+        return provideStringProvider(this.contextProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideUpdateStationsObserverFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.usecases.stations.GetStationsUseCase;
+import com.adif.elcanomovil.observers.UpdateStationsObserver;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideUpdateStationsObserverFactory implements Factory<UpdateStationsObserver> {
+    private final Provider<GetStationsUseCase> getStationsUseCaseProvider;
+
+    public ApplicationModule_Companion_ProvideUpdateStationsObserverFactory(Provider<GetStationsUseCase> provider) {
+        this.getStationsUseCaseProvider = provider;
+    }
+
+    public static ApplicationModule_Companion_ProvideUpdateStationsObserverFactory create(Provider<GetStationsUseCase> provider) {
+        return new ApplicationModule_Companion_ProvideUpdateStationsObserverFactory(provider);
+    }
+
+    public static UpdateStationsObserver provideUpdateStationsObserver(GetStationsUseCase getStationsUseCase) {
+        return (UpdateStationsObserver) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideUpdateStationsObserver(getStationsUseCase));
+    }
+
+    @Override // javax.inject.Provider
+    public UpdateStationsObserver get() {
+        return provideUpdateStationsObserver(this.getStationsUseCaseProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvideWidgetPayloadHandlerFactory.java

@@ -0,0 +1,28 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.widget.WidgetPayloadHandler;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import g1.e;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvideWidgetPayloadHandlerFactory implements Factory<WidgetPayloadHandler> {
+    public static ApplicationModule_Companion_ProvideWidgetPayloadHandlerFactory create() {
+        return e.f6740a;
+    }
+
+    public static WidgetPayloadHandler provideWidgetPayloadHandler() {
+        return (WidgetPayloadHandler) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.provideWidgetPayloadHandler());
+    }
+
+    @Override // javax.inject.Provider
+    public WidgetPayloadHandler get() {
+        return provideWidgetPayloadHandler();
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/ApplicationModule_Companion_ProvidesDateFormatFactory.java

@@ -0,0 +1,28 @@
+package com.adif.elcanomovil.di;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import g1.f;
+import java.text.DateFormat;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class ApplicationModule_Companion_ProvidesDateFormatFactory implements Factory<DateFormat> {
+    public static ApplicationModule_Companion_ProvidesDateFormatFactory create() {
+        return f.f6741a;
+    }
+
+    public static DateFormat providesDateFormat() {
+        return (DateFormat) Preconditions.checkNotNullFromProvides(ApplicationModule.INSTANCE.providesDateFormat());
+    }
+
+    @Override // javax.inject.Provider
+    public DateFormat get() {
+        return providesDateFormat();
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideActiveSubscriptionsUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.subscriptions.SubscriptionRepository;
+import com.adif.elcanomovil.domain.usecases.subscriptions.subscriptions.ActiveSubscriptionsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideActiveSubscriptionsUseCaseFactory implements Factory<ActiveSubscriptionsUseCase> {
+    private final Provider<SubscriptionRepository> subscriptionRepositoryProvider;
+
+    public UseCases_ProvideActiveSubscriptionsUseCaseFactory(Provider<SubscriptionRepository> provider) {
+        this.subscriptionRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideActiveSubscriptionsUseCaseFactory create(Provider<SubscriptionRepository> provider) {
+        return new UseCases_ProvideActiveSubscriptionsUseCaseFactory(provider);
+    }
+
+    public static ActiveSubscriptionsUseCase provideActiveSubscriptionsUseCase(SubscriptionRepository subscriptionRepository) {
+        return (ActiveSubscriptionsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideActiveSubscriptionsUseCase(subscriptionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public ActiveSubscriptionsUseCase get() {
+        return provideActiveSubscriptionsUseCase(this.subscriptionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideCreateIncidenceUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.avisa.IncidenceRepository;
+import com.adif.elcanomovil.domain.usecases.avisa.incidence.CreateIncidenceUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideCreateIncidenceUseCaseFactory implements Factory<CreateIncidenceUseCase> {
+    private final Provider<IncidenceRepository> incidenceRepositoryProvider;
+
+    public UseCases_ProvideCreateIncidenceUseCaseFactory(Provider<IncidenceRepository> provider) {
+        this.incidenceRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideCreateIncidenceUseCaseFactory create(Provider<IncidenceRepository> provider) {
+        return new UseCases_ProvideCreateIncidenceUseCaseFactory(provider);
+    }
+
+    public static CreateIncidenceUseCase provideCreateIncidenceUseCase(IncidenceRepository incidenceRepository) {
+        return (CreateIncidenceUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideCreateIncidenceUseCase(incidenceRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public CreateIncidenceUseCase get() {
+        return provideCreateIncidenceUseCase(this.incidenceRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideCreateSubscriptionsdUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.subscriptions.SubscriptionRepository;
+import com.adif.elcanomovil.domain.usecases.subscriptions.subscriptions.CreateSubscriptionsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideCreateSubscriptionsdUseCaseFactory implements Factory<CreateSubscriptionsUseCase> {
+    private final Provider<SubscriptionRepository> subscriptionRepositoryProvider;
+
+    public UseCases_ProvideCreateSubscriptionsdUseCaseFactory(Provider<SubscriptionRepository> provider) {
+        this.subscriptionRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideCreateSubscriptionsdUseCaseFactory create(Provider<SubscriptionRepository> provider) {
+        return new UseCases_ProvideCreateSubscriptionsdUseCaseFactory(provider);
+    }
+
+    public static CreateSubscriptionsUseCase provideCreateSubscriptionsdUseCase(SubscriptionRepository subscriptionRepository) {
+        return (CreateSubscriptionsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideCreateSubscriptionsdUseCase(subscriptionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public CreateSubscriptionsUseCase get() {
+        return provideCreateSubscriptionsdUseCase(this.subscriptionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideDeleteSubscriptionsdUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.subscriptions.SubscriptionRepository;
+import com.adif.elcanomovil.domain.usecases.subscriptions.subscriptions.DeleteSubscriptionsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideDeleteSubscriptionsdUseCaseFactory implements Factory<DeleteSubscriptionsUseCase> {
+    private final Provider<SubscriptionRepository> subscriptionRepositoryProvider;
+
+    public UseCases_ProvideDeleteSubscriptionsdUseCaseFactory(Provider<SubscriptionRepository> provider) {
+        this.subscriptionRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideDeleteSubscriptionsdUseCaseFactory create(Provider<SubscriptionRepository> provider) {
+        return new UseCases_ProvideDeleteSubscriptionsdUseCaseFactory(provider);
+    }
+
+    public static DeleteSubscriptionsUseCase provideDeleteSubscriptionsdUseCase(SubscriptionRepository subscriptionRepository) {
+        return (DeleteSubscriptionsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideDeleteSubscriptionsdUseCase(subscriptionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public DeleteSubscriptionsUseCase get() {
+        return provideDeleteSubscriptionsdUseCase(this.subscriptionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideFetchVersionUpdateUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.RemoteConfigVersionRepository;
+import com.adif.elcanomovil.domain.usecases.FetchVersionUpdateUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideFetchVersionUpdateUseCaseFactory implements Factory<FetchVersionUpdateUseCase> {
+    private final Provider<RemoteConfigVersionRepository> remoteConfigVersionRepositoryProvider;
+
+    public UseCases_ProvideFetchVersionUpdateUseCaseFactory(Provider<RemoteConfigVersionRepository> provider) {
+        this.remoteConfigVersionRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideFetchVersionUpdateUseCaseFactory create(Provider<RemoteConfigVersionRepository> provider) {
+        return new UseCases_ProvideFetchVersionUpdateUseCaseFactory(provider);
+    }
+
+    public static FetchVersionUpdateUseCase provideFetchVersionUpdateUseCase(RemoteConfigVersionRepository remoteConfigVersionRepository) {
+        return (FetchVersionUpdateUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideFetchVersionUpdateUseCase(remoteConfigVersionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public FetchVersionUpdateUseCase get() {
+        return provideFetchVersionUpdateUseCase(this.remoteConfigVersionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGenerateDynamicLinkFacadeFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.DynamicLinkFacade;
+import com.google.firebase.dynamiclinks.FirebaseDynamicLinks;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGenerateDynamicLinkFacadeFactory implements Factory<DynamicLinkFacade> {
+    private final Provider<FirebaseDynamicLinks> firebaseDynamicLinksProvider;
+
+    public UseCases_ProvideGenerateDynamicLinkFacadeFactory(Provider<FirebaseDynamicLinks> provider) {
+        this.firebaseDynamicLinksProvider = provider;
+    }
+
+    public static UseCases_ProvideGenerateDynamicLinkFacadeFactory create(Provider<FirebaseDynamicLinks> provider) {
+        return new UseCases_ProvideGenerateDynamicLinkFacadeFactory(provider);
+    }
+
+    public static DynamicLinkFacade provideGenerateDynamicLinkFacade(FirebaseDynamicLinks firebaseDynamicLinks) {
+        return (DynamicLinkFacade) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGenerateDynamicLinkFacade(firebaseDynamicLinks));
+    }
+
+    @Override // javax.inject.Provider
+    public DynamicLinkFacade get() {
+        return provideGenerateDynamicLinkFacade(this.firebaseDynamicLinksProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGenerateDynamicLinkUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.DynamicLinkFacade;
+import com.adif.elcanomovil.domain.usecases.DynamicLinkUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGenerateDynamicLinkUseCaseFactory implements Factory<DynamicLinkUseCase> {
+    private final Provider<DynamicLinkFacade> dynamicLinkFacadeProvider;
+
+    public UseCases_ProvideGenerateDynamicLinkUseCaseFactory(Provider<DynamicLinkFacade> provider) {
+        this.dynamicLinkFacadeProvider = provider;
+    }
+
+    public static UseCases_ProvideGenerateDynamicLinkUseCaseFactory create(Provider<DynamicLinkFacade> provider) {
+        return new UseCases_ProvideGenerateDynamicLinkUseCaseFactory(provider);
+    }
+
+    public static DynamicLinkUseCase provideGenerateDynamicLinkUseCase(DynamicLinkFacade dynamicLinkFacade) {
+        return (DynamicLinkUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGenerateDynamicLinkUseCase(dynamicLinkFacade));
+    }
+
+    @Override // javax.inject.Provider
+    public DynamicLinkUseCase get() {
+        return provideGenerateDynamicLinkUseCase(this.dynamicLinkFacadeProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGeneratePasswordUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.CredentialsProvider;
+import com.adif.elcanomovil.domain.usecases.credentials.GeneratePasswordUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGeneratePasswordUseCaseFactory implements Factory<GeneratePasswordUseCase> {
+    private final Provider<CredentialsProvider> credentialsProvider;
+
+    public UseCases_ProvideGeneratePasswordUseCaseFactory(Provider<CredentialsProvider> provider) {
+        this.credentialsProvider = provider;
+    }
+
+    public static UseCases_ProvideGeneratePasswordUseCaseFactory create(Provider<CredentialsProvider> provider) {
+        return new UseCases_ProvideGeneratePasswordUseCaseFactory(provider);
+    }
+
+    public static GeneratePasswordUseCase provideGeneratePasswordUseCase(CredentialsProvider credentialsProvider) {
+        return (GeneratePasswordUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGeneratePasswordUseCase(credentialsProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public GeneratePasswordUseCase get() {
+        return provideGeneratePasswordUseCase(this.credentialsProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGeneratePersistentUserIdUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.CredentialsProvider;
+import com.adif.elcanomovil.domain.usecases.credentials.GeneratePersistentUserIdUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGeneratePersistentUserIdUseCaseFactory implements Factory<GeneratePersistentUserIdUseCase> {
+    private final Provider<CredentialsProvider> credentialsProvider;
+
+    public UseCases_ProvideGeneratePersistentUserIdUseCaseFactory(Provider<CredentialsProvider> provider) {
+        this.credentialsProvider = provider;
+    }
+
+    public static UseCases_ProvideGeneratePersistentUserIdUseCaseFactory create(Provider<CredentialsProvider> provider) {
+        return new UseCases_ProvideGeneratePersistentUserIdUseCaseFactory(provider);
+    }
+
+    public static GeneratePersistentUserIdUseCase provideGeneratePersistentUserIdUseCase(CredentialsProvider credentialsProvider) {
+        return (GeneratePersistentUserIdUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGeneratePersistentUserIdUseCase(credentialsProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public GeneratePersistentUserIdUseCase get() {
+        return provideGeneratePersistentUserIdUseCase(this.credentialsProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGenerateUserIdUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.CredentialsProvider;
+import com.adif.elcanomovil.domain.usecases.credentials.GenerateUserIdUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGenerateUserIdUseCaseFactory implements Factory<GenerateUserIdUseCase> {
+    private final Provider<CredentialsProvider> credentialsProvider;
+
+    public UseCases_ProvideGenerateUserIdUseCaseFactory(Provider<CredentialsProvider> provider) {
+        this.credentialsProvider = provider;
+    }
+
+    public static UseCases_ProvideGenerateUserIdUseCaseFactory create(Provider<CredentialsProvider> provider) {
+        return new UseCases_ProvideGenerateUserIdUseCaseFactory(provider);
+    }
+
+    public static GenerateUserIdUseCase provideGenerateUserIdUseCase(CredentialsProvider credentialsProvider) {
+        return (GenerateUserIdUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGenerateUserIdUseCase(credentialsProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public GenerateUserIdUseCase get() {
+        return provideGenerateUserIdUseCase(this.credentialsProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetAppVersionUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.AppVersionProvider;
+import com.adif.elcanomovil.domain.usecases.GetAppVersionUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetAppVersionUseCaseFactory implements Factory<GetAppVersionUseCase> {
+    private final Provider<AppVersionProvider> appVersionProvider;
+
+    public UseCases_ProvideGetAppVersionUseCaseFactory(Provider<AppVersionProvider> provider) {
+        this.appVersionProvider = provider;
+    }
+
+    public static UseCases_ProvideGetAppVersionUseCaseFactory create(Provider<AppVersionProvider> provider) {
+        return new UseCases_ProvideGetAppVersionUseCaseFactory(provider);
+    }
+
+    public static GetAppVersionUseCase provideGetAppVersionUseCase(AppVersionProvider appVersionProvider) {
+        return (GetAppVersionUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetAppVersionUseCase(appVersionProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public GetAppVersionUseCase get() {
+        return provideGetAppVersionUseCase(this.appVersionProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetAvisaStationsCategoriesUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.avisa.AvisaStationsRepository;
+import com.adif.elcanomovil.domain.usecases.avisa.station.GetAvisaStationCategoriesUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetAvisaStationsCategoriesUseCaseFactory implements Factory<GetAvisaStationCategoriesUseCase> {
+    private final Provider<AvisaStationsRepository> avisaStationsRepositoryProvider;
+
+    public UseCases_ProvideGetAvisaStationsCategoriesUseCaseFactory(Provider<AvisaStationsRepository> provider) {
+        this.avisaStationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetAvisaStationsCategoriesUseCaseFactory create(Provider<AvisaStationsRepository> provider) {
+        return new UseCases_ProvideGetAvisaStationsCategoriesUseCaseFactory(provider);
+    }
+
+    public static GetAvisaStationCategoriesUseCase provideGetAvisaStationsCategoriesUseCase(AvisaStationsRepository avisaStationsRepository) {
+        return (GetAvisaStationCategoriesUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetAvisaStationsCategoriesUseCase(avisaStationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetAvisaStationCategoriesUseCase get() {
+        return provideGetAvisaStationsCategoriesUseCase(this.avisaStationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetAvisaStationsUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.avisa.AvisaStationsRepository;
+import com.adif.elcanomovil.domain.usecases.avisa.station.GetAvisaStationsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetAvisaStationsUseCaseFactory implements Factory<GetAvisaStationsUseCase> {
+    private final Provider<AvisaStationsRepository> avisaStationsRepositoryProvider;
+
+    public UseCases_ProvideGetAvisaStationsUseCaseFactory(Provider<AvisaStationsRepository> provider) {
+        this.avisaStationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetAvisaStationsUseCaseFactory create(Provider<AvisaStationsRepository> provider) {
+        return new UseCases_ProvideGetAvisaStationsUseCaseFactory(provider);
+    }
+
+    public static GetAvisaStationsUseCase provideGetAvisaStationsUseCase(AvisaStationsRepository avisaStationsRepository) {
+        return (GetAvisaStationsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetAvisaStationsUseCase(avisaStationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetAvisaStationsUseCase get() {
+        return provideGetAvisaStationsUseCase(this.avisaStationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetBetweenStationsUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetBetweenStationsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetBetweenStationsUseCaseFactory implements Factory<GetBetweenStationsUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideGetBetweenStationsUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetBetweenStationsUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideGetBetweenStationsUseCaseFactory(provider);
+    }
+
+    public static GetBetweenStationsUseCase provideGetBetweenStationsUseCase(CirculationRepository circulationRepository) {
+        return (GetBetweenStationsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetBetweenStationsUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetBetweenStationsUseCase get() {
+        return provideGetBetweenStationsUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetCirculationUpdateTimeUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.RemoteConfigVersionRepository;
+import com.adif.elcanomovil.domain.usecases.GetCirculationUpdateTimeUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetCirculationUpdateTimeUseCaseFactory implements Factory<GetCirculationUpdateTimeUseCase> {
+    private final Provider<RemoteConfigVersionRepository> remoteConfigVersionRepositoryProvider;
+
+    public UseCases_ProvideGetCirculationUpdateTimeUseCaseFactory(Provider<RemoteConfigVersionRepository> provider) {
+        this.remoteConfigVersionRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetCirculationUpdateTimeUseCaseFactory create(Provider<RemoteConfigVersionRepository> provider) {
+        return new UseCases_ProvideGetCirculationUpdateTimeUseCaseFactory(provider);
+    }
+
+    public static GetCirculationUpdateTimeUseCase provideGetCirculationUpdateTimeUseCase(RemoteConfigVersionRepository remoteConfigVersionRepository) {
+        return (GetCirculationUpdateTimeUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetCirculationUpdateTimeUseCase(remoteConfigVersionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetCirculationUpdateTimeUseCase get() {
+        return provideGetCirculationUpdateTimeUseCase(this.remoteConfigVersionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetClosestStationUseCaseFactory.java

@@ -0,0 +1,41 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.Check24hProvider;
+import com.adif.elcanomovil.domain.providers.LocationProvider;
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetClosestStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetClosestStationUseCaseFactory implements Factory<GetClosestStationUseCase> {
+    private final Provider<Check24hProvider> check24hProvider;
+    private final Provider<LocationProvider> locationProvider;
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetClosestStationUseCaseFactory(Provider<LocationProvider> provider, Provider<StationsRepository> provider2, Provider<Check24hProvider> provider3) {
+        this.locationProvider = provider;
+        this.stationsRepositoryProvider = provider2;
+        this.check24hProvider = provider3;
+    }
+
+    public static UseCases_ProvideGetClosestStationUseCaseFactory create(Provider<LocationProvider> provider, Provider<StationsRepository> provider2, Provider<Check24hProvider> provider3) {
+        return new UseCases_ProvideGetClosestStationUseCaseFactory(provider, provider2, provider3);
+    }
+
+    public static GetClosestStationUseCase provideGetClosestStationUseCase(LocationProvider locationProvider, StationsRepository stationsRepository, Check24hProvider check24hProvider) {
+        return (GetClosestStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetClosestStationUseCase(locationProvider, stationsRepository, check24hProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public GetClosestStationUseCase get() {
+        return provideGetClosestStationUseCase(this.locationProvider.get(), this.stationsRepositoryProvider.get(), this.check24hProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetCompositionsUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.compositions.CompositionsRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetCompositionsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetCompositionsUseCaseFactory implements Factory<GetCompositionsUseCase> {
+    private final Provider<CompositionsRepository> compositionsRepositoryProvider;
+
+    public UseCases_ProvideGetCompositionsUseCaseFactory(Provider<CompositionsRepository> provider) {
+        this.compositionsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetCompositionsUseCaseFactory create(Provider<CompositionsRepository> provider) {
+        return new UseCases_ProvideGetCompositionsUseCaseFactory(provider);
+    }
+
+    public static GetCompositionsUseCase provideGetCompositionsUseCase(CompositionsRepository compositionsRepository) {
+        return (GetCompositionsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetCompositionsUseCase(compositionsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetCompositionsUseCase get() {
+        return provideGetCompositionsUseCase(this.compositionsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetCurrentOneStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetCurrentOneStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetCurrentOneStationUseCaseFactory implements Factory<GetCurrentOneStationUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetCurrentOneStationUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetCurrentOneStationUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideGetCurrentOneStationUseCaseFactory(provider);
+    }
+
+    public static GetCurrentOneStationUseCase provideGetCurrentOneStationUseCase(StationsRepository stationsRepository) {
+        return (GetCurrentOneStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetCurrentOneStationUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetCurrentOneStationUseCase get() {
+        return provideGetCurrentOneStationUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetDepartureCirculationsUseCaseFactory.java

@@ -0,0 +1,53 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.entities.circulation.mappers.AvldmdCirculationMapper;
+import com.adif.elcanomovil.domain.entities.circulation.mappers.CercaniasCirculationMapper;
+import com.adif.elcanomovil.domain.entities.circulation.mappers.OthersCirculationMapper;
+import com.adif.elcanomovil.domain.usecases.circulation.GetBetweenStationsUseCase;
+import com.adif.elcanomovil.domain.usecases.circulation.GetDepartureCirculationsUseCase;
+import com.adif.elcanomovil.domain.usecases.circulation.GetStationArrivalsUseCase;
+import com.adif.elcanomovil.domain.usecases.circulation.GetStationDeparturesUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import java.text.DateFormat;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetDepartureCirculationsUseCaseFactory implements Factory<GetDepartureCirculationsUseCase> {
+    private final Provider<AvldmdCirculationMapper> avldmdCirculationMapperProvider;
+    private final Provider<CercaniasCirculationMapper> cercaniasCirculationMapperProvider;
+    private final Provider<DateFormat> formatterProvider;
+    private final Provider<GetBetweenStationsUseCase> getBetweenStationsUseCaseProvider;
+    private final Provider<GetStationArrivalsUseCase> getStationArrivalsUseCaseProvider;
+    private final Provider<GetStationDeparturesUseCase> getStationDeparturesUseCaseProvider;
+    private final Provider<OthersCirculationMapper> otherCirculationMapperProvider;
+
+    public UseCases_ProvideGetDepartureCirculationsUseCaseFactory(Provider<GetStationArrivalsUseCase> provider, Provider<GetStationDeparturesUseCase> provider2, Provider<GetBetweenStationsUseCase> provider3, Provider<CercaniasCirculationMapper> provider4, Provider<AvldmdCirculationMapper> provider5, Provider<OthersCirculationMapper> provider6, Provider<DateFormat> provider7) {
+        this.getStationArrivalsUseCaseProvider = provider;
+        this.getStationDeparturesUseCaseProvider = provider2;
+        this.getBetweenStationsUseCaseProvider = provider3;
+        this.cercaniasCirculationMapperProvider = provider4;
+        this.avldmdCirculationMapperProvider = provider5;
+        this.otherCirculationMapperProvider = provider6;
+        this.formatterProvider = provider7;
+    }
+
+    public static UseCases_ProvideGetDepartureCirculationsUseCaseFactory create(Provider<GetStationArrivalsUseCase> provider, Provider<GetStationDeparturesUseCase> provider2, Provider<GetBetweenStationsUseCase> provider3, Provider<CercaniasCirculationMapper> provider4, Provider<AvldmdCirculationMapper> provider5, Provider<OthersCirculationMapper> provider6, Provider<DateFormat> provider7) {
+        return new UseCases_ProvideGetDepartureCirculationsUseCaseFactory(provider, provider2, provider3, provider4, provider5, provider6, provider7);
+    }
+
+    public static GetDepartureCirculationsUseCase provideGetDepartureCirculationsUseCase(GetStationArrivalsUseCase getStationArrivalsUseCase, GetStationDeparturesUseCase getStationDeparturesUseCase, GetBetweenStationsUseCase getBetweenStationsUseCase, CercaniasCirculationMapper cercaniasCirculationMapper, AvldmdCirculationMapper avldmdCirculationMapper, OthersCirculationMapper othersCirculationMapper, DateFormat dateFormat) {
+        return (GetDepartureCirculationsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetDepartureCirculationsUseCase(getStationArrivalsUseCase, getStationDeparturesUseCase, getBetweenStationsUseCase, cercaniasCirculationMapper, avldmdCirculationMapper, othersCirculationMapper, dateFormat));
+    }
+
+    @Override // javax.inject.Provider
+    public GetDepartureCirculationsUseCase get() {
+        return provideGetDepartureCirculationsUseCase(this.getStationArrivalsUseCaseProvider.get(), this.getStationDeparturesUseCaseProvider.get(), this.getBetweenStationsUseCaseProvider.get(), this.cercaniasCirculationMapperProvider.get(), this.avldmdCirculationMapperProvider.get(), this.otherCirculationMapperProvider.get(), this.formatterProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetDistanceStationUseCaseFactory.java

@@ -0,0 +1,38 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.LocationProvider;
+import com.adif.elcanomovil.domain.usecases.recentSearch.GetRecentSearchesUseCase;
+import com.adif.elcanomovil.domain.usecases.stations.ObserveRecentlySearchedStationsWithDistanceUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetDistanceStationUseCaseFactory implements Factory<ObserveRecentlySearchedStationsWithDistanceUseCase> {
+    private final Provider<GetRecentSearchesUseCase> getRecentStationsProvider;
+    private final Provider<LocationProvider> locationProvider;
+
+    public UseCases_ProvideGetDistanceStationUseCaseFactory(Provider<LocationProvider> provider, Provider<GetRecentSearchesUseCase> provider2) {
+        this.locationProvider = provider;
+        this.getRecentStationsProvider = provider2;
+    }
+
+    public static UseCases_ProvideGetDistanceStationUseCaseFactory create(Provider<LocationProvider> provider, Provider<GetRecentSearchesUseCase> provider2) {
+        return new UseCases_ProvideGetDistanceStationUseCaseFactory(provider, provider2);
+    }
+
+    public static ObserveRecentlySearchedStationsWithDistanceUseCase provideGetDistanceStationUseCase(LocationProvider locationProvider, GetRecentSearchesUseCase getRecentSearchesUseCase) {
+        return (ObserveRecentlySearchedStationsWithDistanceUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetDistanceStationUseCase(locationProvider, getRecentSearchesUseCase));
+    }
+
+    @Override // javax.inject.Provider
+    public ObserveRecentlySearchedStationsWithDistanceUseCase get() {
+        return provideGetDistanceStationUseCase(this.locationProvider.get(), this.getRecentStationsProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetFavoritesUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetStationsFavoritesUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetFavoritesUseCaseFactory implements Factory<GetStationsFavoritesUseCase> {
+    private final Provider<FavoritesRepository> favoriteRepositoryProvider;
+
+    public UseCases_ProvideGetFavoritesUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.favoriteRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetFavoritesUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideGetFavoritesUseCaseFactory(provider);
+    }
+
+    public static GetStationsFavoritesUseCase provideGetFavoritesUseCase(FavoritesRepository favoritesRepository) {
+        return (GetStationsFavoritesUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetFavoritesUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationsFavoritesUseCase get() {
+        return provideGetFavoritesUseCase(this.favoriteRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetFiltersUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.filters.FiltersRepository;
+import com.adif.elcanomovil.domain.usecases.filters.GetFiltersUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetFiltersUseCaseFactory implements Factory<GetFiltersUseCase> {
+    private final Provider<FiltersRepository> filtersRepositoryProvider;
+
+    public UseCases_ProvideGetFiltersUseCaseFactory(Provider<FiltersRepository> provider) {
+        this.filtersRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetFiltersUseCaseFactory create(Provider<FiltersRepository> provider) {
+        return new UseCases_ProvideGetFiltersUseCaseFactory(provider);
+    }
+
+    public static GetFiltersUseCase provideGetFiltersUseCase(FiltersRepository filtersRepository) {
+        return (GetFiltersUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetFiltersUseCase(filtersRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetFiltersUseCase get() {
+        return provideGetFiltersUseCase(this.filtersRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetHomeStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetHomeStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetHomeStationUseCaseFactory implements Factory<GetHomeStationUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetHomeStationUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetHomeStationUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideGetHomeStationUseCaseFactory(provider);
+    }
+
+    public static GetHomeStationUseCase provideGetHomeStationUseCase(StationsRepository stationsRepository) {
+        return (GetHomeStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetHomeStationUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetHomeStationUseCase get() {
+        return provideGetHomeStationUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetIncidenceDetailUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.avisa.IncidenceRepository;
+import com.adif.elcanomovil.domain.usecases.avisa.incidence.GetIncidenceDetailsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetIncidenceDetailUseCaseFactory implements Factory<GetIncidenceDetailsUseCase> {
+    private final Provider<IncidenceRepository> incidenceRepositoryProvider;
+
+    public UseCases_ProvideGetIncidenceDetailUseCaseFactory(Provider<IncidenceRepository> provider) {
+        this.incidenceRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetIncidenceDetailUseCaseFactory create(Provider<IncidenceRepository> provider) {
+        return new UseCases_ProvideGetIncidenceDetailUseCaseFactory(provider);
+    }
+
+    public static GetIncidenceDetailsUseCase provideGetIncidenceDetailUseCase(IncidenceRepository incidenceRepository) {
+        return (GetIncidenceDetailsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetIncidenceDetailUseCase(incidenceRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetIncidenceDetailsUseCase get() {
+        return provideGetIncidenceDetailUseCase(this.incidenceRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetIncidencesUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.avisa.IncidenceRepository;
+import com.adif.elcanomovil.domain.usecases.avisa.incidence.GetIncidencesUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetIncidencesUseCaseFactory implements Factory<GetIncidencesUseCase> {
+    private final Provider<IncidenceRepository> incidenceRepositoryProvider;
+
+    public UseCases_ProvideGetIncidencesUseCaseFactory(Provider<IncidenceRepository> provider) {
+        this.incidenceRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetIncidencesUseCaseFactory create(Provider<IncidenceRepository> provider) {
+        return new UseCases_ProvideGetIncidencesUseCaseFactory(provider);
+    }
+
+    public static GetIncidencesUseCase provideGetIncidencesUseCase(IncidenceRepository incidenceRepository) {
+        return (GetIncidencesUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetIncidencesUseCase(incidenceRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetIncidencesUseCase get() {
+        return provideGetIncidencesUseCase(this.incidenceRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetLastDepartureTypeTrainIsCercaniasUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetLastDepartureTypeTrainIsCercaniasUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetLastDepartureTypeTrainIsCercaniasUseCaseFactory implements Factory<GetLastDepartureTypeTrainIsCercaniasUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideGetLastDepartureTypeTrainIsCercaniasUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetLastDepartureTypeTrainIsCercaniasUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideGetLastDepartureTypeTrainIsCercaniasUseCaseFactory(provider);
+    }
+
+    public static GetLastDepartureTypeTrainIsCercaniasUseCase provideGetLastDepartureTypeTrainIsCercaniasUseCase(CirculationRepository circulationRepository) {
+        return (GetLastDepartureTypeTrainIsCercaniasUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetLastDepartureTypeTrainIsCercaniasUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetLastDepartureTypeTrainIsCercaniasUseCase get() {
+        return provideGetLastDepartureTypeTrainIsCercaniasUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetLastDeparturesArrivalsStationToUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetLastDeparturesArrivalsStationToUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetLastDeparturesArrivalsStationToUseCaseFactory implements Factory<GetLastDeparturesArrivalsStationToUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideGetLastDeparturesArrivalsStationToUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetLastDeparturesArrivalsStationToUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideGetLastDeparturesArrivalsStationToUseCaseFactory(provider);
+    }
+
+    public static GetLastDeparturesArrivalsStationToUseCase provideGetLastDeparturesArrivalsStationToUseCase(CirculationRepository circulationRepository) {
+        return (GetLastDeparturesArrivalsStationToUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetLastDeparturesArrivalsStationToUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetLastDeparturesArrivalsStationToUseCase get() {
+        return provideGetLastDeparturesArrivalsStationToUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetLastDeparturesArrivalsStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetLastDeparturesArrivalsStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetLastDeparturesArrivalsStationUseCaseFactory implements Factory<GetLastDeparturesArrivalsStationUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideGetLastDeparturesArrivalsStationUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetLastDeparturesArrivalsStationUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideGetLastDeparturesArrivalsStationUseCaseFactory(provider);
+    }
+
+    public static GetLastDeparturesArrivalsStationUseCase provideGetLastDeparturesArrivalsStationUseCase(CirculationRepository circulationRepository) {
+        return (GetLastDeparturesArrivalsStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetLastDeparturesArrivalsStationUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetLastDeparturesArrivalsStationUseCase get() {
+        return provideGetLastDeparturesArrivalsStationUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetLastVisitedStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetLastVisitedStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetLastVisitedStationUseCaseFactory implements Factory<GetLastVisitedStationUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetLastVisitedStationUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetLastVisitedStationUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideGetLastVisitedStationUseCaseFactory(provider);
+    }
+
+    public static GetLastVisitedStationUseCase provideGetLastVisitedStationUseCase(StationsRepository stationsRepository) {
+        return (GetLastVisitedStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetLastVisitedStationUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetLastVisitedStationUseCase get() {
+        return provideGetLastVisitedStationUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetOnePathsUseCaseFactory.java

@@ -0,0 +1,38 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.RemoteConfigVersionRepository;
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetOnePathsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetOnePathsUseCaseFactory implements Factory<GetOnePathsUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+    private final Provider<RemoteConfigVersionRepository> remoteConfigVersionRepositoryProvider;
+
+    public UseCases_ProvideGetOnePathsUseCaseFactory(Provider<CirculationRepository> provider, Provider<RemoteConfigVersionRepository> provider2) {
+        this.circulationRepositoryProvider = provider;
+        this.remoteConfigVersionRepositoryProvider = provider2;
+    }
+
+    public static UseCases_ProvideGetOnePathsUseCaseFactory create(Provider<CirculationRepository> provider, Provider<RemoteConfigVersionRepository> provider2) {
+        return new UseCases_ProvideGetOnePathsUseCaseFactory(provider, provider2);
+    }
+
+    public static GetOnePathsUseCase provideGetOnePathsUseCase(CirculationRepository circulationRepository, RemoteConfigVersionRepository remoteConfigVersionRepository) {
+        return (GetOnePathsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetOnePathsUseCase(circulationRepository, remoteConfigVersionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetOnePathsUseCase get() {
+        return provideGetOnePathsUseCase(this.circulationRepositoryProvider.get(), this.remoteConfigVersionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetOneStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetOneStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetOneStationUseCaseFactory implements Factory<GetOneStationUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetOneStationUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetOneStationUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideGetOneStationUseCaseFactory(provider);
+    }
+
+    public static GetOneStationUseCase provideGetOneStationUseCase(StationsRepository stationsRepository) {
+        return (GetOneStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetOneStationUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetOneStationUseCase get() {
+        return provideGetOneStationUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetRecentSearchesUseCaseFactory.java

@@ -0,0 +1,38 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.searches.SearchesRepository;
+import com.adif.elcanomovil.domain.usecases.recentSearch.GetRecentSearchesUseCase;
+import com.adif.elcanomovil.domain.usecases.stations.GetStationByIdUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetRecentSearchesUseCaseFactory implements Factory<GetRecentSearchesUseCase> {
+    private final Provider<GetStationByIdUseCase> getStationByIdUseCaseProvider;
+    private final Provider<SearchesRepository> searchesRepositoryProvider;
+
+    public UseCases_ProvideGetRecentSearchesUseCaseFactory(Provider<SearchesRepository> provider, Provider<GetStationByIdUseCase> provider2) {
+        this.searchesRepositoryProvider = provider;
+        this.getStationByIdUseCaseProvider = provider2;
+    }
+
+    public static UseCases_ProvideGetRecentSearchesUseCaseFactory create(Provider<SearchesRepository> provider, Provider<GetStationByIdUseCase> provider2) {
+        return new UseCases_ProvideGetRecentSearchesUseCaseFactory(provider, provider2);
+    }
+
+    public static GetRecentSearchesUseCase provideGetRecentSearchesUseCase(SearchesRepository searchesRepository, GetStationByIdUseCase getStationByIdUseCase) {
+        return (GetRecentSearchesUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetRecentSearchesUseCase(searchesRepository, getStationByIdUseCase));
+    }
+
+    @Override // javax.inject.Provider
+    public GetRecentSearchesUseCase get() {
+        return provideGetRecentSearchesUseCase(this.searchesRepositoryProvider.get(), this.getStationByIdUseCaseProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetRecentTrainSearchesUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.searches.SearchesRepository;
+import com.adif.elcanomovil.domain.usecases.recentSearch.GetRecentTrainSearchesUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetRecentTrainSearchesUseCaseFactory implements Factory<GetRecentTrainSearchesUseCase> {
+    private final Provider<SearchesRepository> searchesRepositoryProvider;
+
+    public UseCases_ProvideGetRecentTrainSearchesUseCaseFactory(Provider<SearchesRepository> provider) {
+        this.searchesRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetRecentTrainSearchesUseCaseFactory create(Provider<SearchesRepository> provider) {
+        return new UseCases_ProvideGetRecentTrainSearchesUseCaseFactory(provider);
+    }
+
+    public static GetRecentTrainSearchesUseCase provideGetRecentTrainSearchesUseCase(SearchesRepository searchesRepository) {
+        return (GetRecentTrainSearchesUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetRecentTrainSearchesUseCase(searchesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetRecentTrainSearchesUseCase get() {
+        return provideGetRecentTrainSearchesUseCase(this.searchesRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetRelationStationsFavoritesUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetRelationStationsFavoritesUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetRelationStationsFavoritesUseCaseFactory implements Factory<GetRelationStationsFavoritesUseCase> {
+    private final Provider<FavoritesRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetRelationStationsFavoritesUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetRelationStationsFavoritesUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideGetRelationStationsFavoritesUseCaseFactory(provider);
+    }
+
+    public static GetRelationStationsFavoritesUseCase provideGetRelationStationsFavoritesUseCase(FavoritesRepository favoritesRepository) {
+        return (GetRelationStationsFavoritesUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetRelationStationsFavoritesUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetRelationStationsFavoritesUseCase get() {
+        return provideGetRelationStationsFavoritesUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetSeveralPathsUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetSeveralPathsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetSeveralPathsUseCaseFactory implements Factory<GetSeveralPathsUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideGetSeveralPathsUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetSeveralPathsUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideGetSeveralPathsUseCaseFactory(provider);
+    }
+
+    public static GetSeveralPathsUseCase provideGetSeveralPathsUseCase(CirculationRepository circulationRepository) {
+        return (GetSeveralPathsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetSeveralPathsUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetSeveralPathsUseCase get() {
+        return provideGetSeveralPathsUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetStationArrivalsUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetStationArrivalsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetStationArrivalsUseCaseFactory implements Factory<GetStationArrivalsUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideGetStationArrivalsUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetStationArrivalsUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideGetStationArrivalsUseCaseFactory(provider);
+    }
+
+    public static GetStationArrivalsUseCase provideGetStationArrivalsUseCase(CirculationRepository circulationRepository) {
+        return (GetStationArrivalsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetStationArrivalsUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationArrivalsUseCase get() {
+        return provideGetStationArrivalsUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetStationByIdUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetStationByIdUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetStationByIdUseCaseFactory implements Factory<GetStationByIdUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetStationByIdUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetStationByIdUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideGetStationByIdUseCaseFactory(provider);
+    }
+
+    public static GetStationByIdUseCase provideGetStationByIdUseCase(StationsRepository stationsRepository) {
+        return (GetStationByIdUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetStationByIdUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationByIdUseCase get() {
+        return provideGetStationByIdUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetStationByNameUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetStationByNameUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetStationByNameUseCaseFactory implements Factory<GetStationByNameUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetStationByNameUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetStationByNameUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideGetStationByNameUseCaseFactory(provider);
+    }
+
+    public static GetStationByNameUseCase provideGetStationByNameUseCase(StationsRepository stationsRepository) {
+        return (GetStationByNameUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetStationByNameUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationByNameUseCase get() {
+        return provideGetStationByNameUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetStationDeparturesUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetStationDeparturesUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetStationDeparturesUseCaseFactory implements Factory<GetStationDeparturesUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideGetStationDeparturesUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetStationDeparturesUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideGetStationDeparturesUseCaseFactory(provider);
+    }
+
+    public static GetStationDeparturesUseCase provideGetStationDeparturesUseCase(CirculationRepository circulationRepository) {
+        return (GetStationDeparturesUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetStationDeparturesUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationDeparturesUseCase get() {
+        return provideGetStationDeparturesUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetStationIsFavoriteUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetStationIsFavoriteUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetStationIsFavoriteUseCaseFactory implements Factory<GetStationIsFavoriteUseCase> {
+    private final Provider<FavoritesRepository> favoriteRepositoryProvider;
+
+    public UseCases_ProvideGetStationIsFavoriteUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.favoriteRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetStationIsFavoriteUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideGetStationIsFavoriteUseCaseFactory(provider);
+    }
+
+    public static GetStationIsFavoriteUseCase provideGetStationIsFavoriteUseCase(FavoritesRepository favoritesRepository) {
+        return (GetStationIsFavoriteUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetStationIsFavoriteUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationIsFavoriteUseCase get() {
+        return provideGetStationIsFavoriteUseCase(this.favoriteRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetStationsForRegionUseCaseFactory.java

@@ -0,0 +1,41 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.Check24hProvider;
+import com.adif.elcanomovil.domain.providers.LocationProvider;
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetStationsForRegionUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetStationsForRegionUseCaseFactory implements Factory<GetStationsForRegionUseCase> {
+    private final Provider<Check24hProvider> check24hProvider;
+    private final Provider<LocationProvider> locationProvider;
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetStationsForRegionUseCaseFactory(Provider<LocationProvider> provider, Provider<StationsRepository> provider2, Provider<Check24hProvider> provider3) {
+        this.locationProvider = provider;
+        this.stationsRepositoryProvider = provider2;
+        this.check24hProvider = provider3;
+    }
+
+    public static UseCases_ProvideGetStationsForRegionUseCaseFactory create(Provider<LocationProvider> provider, Provider<StationsRepository> provider2, Provider<Check24hProvider> provider3) {
+        return new UseCases_ProvideGetStationsForRegionUseCaseFactory(provider, provider2, provider3);
+    }
+
+    public static GetStationsForRegionUseCase provideGetStationsForRegionUseCase(LocationProvider locationProvider, StationsRepository stationsRepository, Check24hProvider check24hProvider) {
+        return (GetStationsForRegionUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetStationsForRegionUseCase(locationProvider, stationsRepository, check24hProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationsForRegionUseCase get() {
+        return provideGetStationsForRegionUseCase(this.locationProvider.get(), this.stationsRepositoryProvider.get(), this.check24hProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetStationsObservationsUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsObservationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetStationsObservationsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetStationsObservationsUseCaseFactory implements Factory<GetStationsObservationsUseCase> {
+    private final Provider<StationsObservationsRepository> stationsObservationsRepositoryProvider;
+
+    public UseCases_ProvideGetStationsObservationsUseCaseFactory(Provider<StationsObservationsRepository> provider) {
+        this.stationsObservationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetStationsObservationsUseCaseFactory create(Provider<StationsObservationsRepository> provider) {
+        return new UseCases_ProvideGetStationsObservationsUseCaseFactory(provider);
+    }
+
+    public static GetStationsObservationsUseCase provideGetStationsObservationsUseCase(StationsObservationsRepository stationsObservationsRepository) {
+        return (GetStationsObservationsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetStationsObservationsUseCase(stationsObservationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationsObservationsUseCase get() {
+        return provideGetStationsObservationsUseCase(this.stationsObservationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetStationsUseCaseFactory.java

@@ -0,0 +1,38 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.Check24hProvider;
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetStationsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetStationsUseCaseFactory implements Factory<GetStationsUseCase> {
+    private final Provider<Check24hProvider> check24hProvider;
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetStationsUseCaseFactory(Provider<StationsRepository> provider, Provider<Check24hProvider> provider2) {
+        this.stationsRepositoryProvider = provider;
+        this.check24hProvider = provider2;
+    }
+
+    public static UseCases_ProvideGetStationsUseCaseFactory create(Provider<StationsRepository> provider, Provider<Check24hProvider> provider2) {
+        return new UseCases_ProvideGetStationsUseCaseFactory(provider, provider2);
+    }
+
+    public static GetStationsUseCase provideGetStationsUseCase(StationsRepository stationsRepository, Check24hProvider check24hProvider) {
+        return (GetStationsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetStationsUseCase(stationsRepository, check24hProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public GetStationsUseCase get() {
+        return provideGetStationsUseCase(this.stationsRepositoryProvider.get(), this.check24hProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetSubscriptionsdUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.subscriptions.SubscriptionRepository;
+import com.adif.elcanomovil.domain.usecases.subscriptions.subscriptions.GetSubscriptionsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetSubscriptionsdUseCaseFactory implements Factory<GetSubscriptionsUseCase> {
+    private final Provider<SubscriptionRepository> subscriptionRepositoryProvider;
+
+    public UseCases_ProvideGetSubscriptionsdUseCaseFactory(Provider<SubscriptionRepository> provider) {
+        this.subscriptionRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetSubscriptionsdUseCaseFactory create(Provider<SubscriptionRepository> provider) {
+        return new UseCases_ProvideGetSubscriptionsdUseCaseFactory(provider);
+    }
+
+    public static GetSubscriptionsUseCase provideGetSubscriptionsdUseCase(SubscriptionRepository subscriptionRepository) {
+        return (GetSubscriptionsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetSubscriptionsdUseCase(subscriptionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetSubscriptionsUseCase get() {
+        return provideGetSubscriptionsdUseCase(this.subscriptionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetTrainIsFavoriteUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetTrainIsFavoriteUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetTrainIsFavoriteUseCaseFactory implements Factory<GetTrainIsFavoriteUseCase> {
+    private final Provider<FavoritesRepository> favoriteRepositoryProvider;
+
+    public UseCases_ProvideGetTrainIsFavoriteUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.favoriteRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetTrainIsFavoriteUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideGetTrainIsFavoriteUseCaseFactory(provider);
+    }
+
+    public static GetTrainIsFavoriteUseCase provideGetTrainIsFavoriteUseCase(FavoritesRepository favoritesRepository) {
+        return (GetTrainIsFavoriteUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetTrainIsFavoriteUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetTrainIsFavoriteUseCase get() {
+        return provideGetTrainIsFavoriteUseCase(this.favoriteRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetTrainsFavoritesUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.GetTrainsFavoritesUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetTrainsFavoritesUseCaseFactory implements Factory<GetTrainsFavoritesUseCase> {
+    private final Provider<FavoritesRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetTrainsFavoritesUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetTrainsFavoritesUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideGetTrainsFavoritesUseCaseFactory(provider);
+    }
+
+    public static GetTrainsFavoritesUseCase provideGetTrainsFavoritesUseCase(FavoritesRepository favoritesRepository) {
+        return (GetTrainsFavoritesUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetTrainsFavoritesUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetTrainsFavoritesUseCase get() {
+        return provideGetTrainsFavoritesUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetUserLastLocationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.LocationProvider;
+import com.adif.elcanomovil.domain.usecases.user.GetUserLastLocationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetUserLastLocationUseCaseFactory implements Factory<GetUserLastLocationUseCase> {
+    private final Provider<LocationProvider> locationProvider;
+
+    public UseCases_ProvideGetUserLastLocationUseCaseFactory(Provider<LocationProvider> provider) {
+        this.locationProvider = provider;
+    }
+
+    public static UseCases_ProvideGetUserLastLocationUseCaseFactory create(Provider<LocationProvider> provider) {
+        return new UseCases_ProvideGetUserLastLocationUseCaseFactory(provider);
+    }
+
+    public static GetUserLastLocationUseCase provideGetUserLastLocationUseCase(LocationProvider locationProvider) {
+        return (GetUserLastLocationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetUserLastLocationUseCase(locationProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public GetUserLastLocationUseCase get() {
+        return provideGetUserLastLocationUseCase(this.locationProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetVersionUpdateStatusUseCaseFactory.java

@@ -0,0 +1,38 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.AppVersionProvider;
+import com.adif.elcanomovil.domain.repositories.RemoteConfigVersionRepository;
+import com.adif.elcanomovil.domain.usecases.GetVersionUpdateStatusUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetVersionUpdateStatusUseCaseFactory implements Factory<GetVersionUpdateStatusUseCase> {
+    private final Provider<AppVersionProvider> appVersionProvider;
+    private final Provider<RemoteConfigVersionRepository> remoteConfigVersionRepositoryProvider;
+
+    public UseCases_ProvideGetVersionUpdateStatusUseCaseFactory(Provider<AppVersionProvider> provider, Provider<RemoteConfigVersionRepository> provider2) {
+        this.appVersionProvider = provider;
+        this.remoteConfigVersionRepositoryProvider = provider2;
+    }
+
+    public static UseCases_ProvideGetVersionUpdateStatusUseCaseFactory create(Provider<AppVersionProvider> provider, Provider<RemoteConfigVersionRepository> provider2) {
+        return new UseCases_ProvideGetVersionUpdateStatusUseCaseFactory(provider, provider2);
+    }
+
+    public static GetVersionUpdateStatusUseCase provideGetVersionUpdateStatusUseCase(AppVersionProvider appVersionProvider, RemoteConfigVersionRepository remoteConfigVersionRepository) {
+        return (GetVersionUpdateStatusUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetVersionUpdateStatusUseCase(appVersionProvider, remoteConfigVersionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetVersionUpdateStatusUseCase get() {
+        return provideGetVersionUpdateStatusUseCase(this.appVersionProvider.get(), this.remoteConfigVersionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideGetWorkStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.GetWorkStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideGetWorkStationUseCaseFactory implements Factory<GetWorkStationUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideGetWorkStationUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideGetWorkStationUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideGetWorkStationUseCaseFactory(provider);
+    }
+
+    public static GetWorkStationUseCase provideGetWorkStationUseCase(StationsRepository stationsRepository) {
+        return (GetWorkStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideGetWorkStationUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public GetWorkStationUseCase get() {
+        return provideGetWorkStationUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideLoginAvisaUserUseCaseFactory.java

@@ -0,0 +1,41 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.avisa.AvisaLoginRepository;
+import com.adif.elcanomovil.domain.usecases.avisa.user.LoginAvisaUserUseCase;
+import com.adif.elcanomovil.domain.usecases.credentials.GeneratePasswordUseCase;
+import com.adif.elcanomovil.domain.usecases.credentials.GenerateUserIdUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideLoginAvisaUserUseCaseFactory implements Factory<LoginAvisaUserUseCase> {
+    private final Provider<AvisaLoginRepository> avisaLoginRepositoryProvider;
+    private final Provider<GeneratePasswordUseCase> generatePasswordUseCaseProvider;
+    private final Provider<GenerateUserIdUseCase> generateUserIdUseCaseProvider;
+
+    public UseCases_ProvideLoginAvisaUserUseCaseFactory(Provider<AvisaLoginRepository> provider, Provider<GeneratePasswordUseCase> provider2, Provider<GenerateUserIdUseCase> provider3) {
+        this.avisaLoginRepositoryProvider = provider;
+        this.generatePasswordUseCaseProvider = provider2;
+        this.generateUserIdUseCaseProvider = provider3;
+    }
+
+    public static UseCases_ProvideLoginAvisaUserUseCaseFactory create(Provider<AvisaLoginRepository> provider, Provider<GeneratePasswordUseCase> provider2, Provider<GenerateUserIdUseCase> provider3) {
+        return new UseCases_ProvideLoginAvisaUserUseCaseFactory(provider, provider2, provider3);
+    }
+
+    public static LoginAvisaUserUseCase provideLoginAvisaUserUseCase(AvisaLoginRepository avisaLoginRepository, GeneratePasswordUseCase generatePasswordUseCase, GenerateUserIdUseCase generateUserIdUseCase) {
+        return (LoginAvisaUserUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideLoginAvisaUserUseCase(avisaLoginRepository, generatePasswordUseCase, generateUserIdUseCase));
+    }
+
+    @Override // javax.inject.Provider
+    public LoginAvisaUserUseCase get() {
+        return provideLoginAvisaUserUseCase(this.avisaLoginRepositoryProvider.get(), this.generatePasswordUseCaseProvider.get(), this.generateUserIdUseCaseProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideManageLogosUseCaseFactory.java

@@ -0,0 +1,38 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.LogoProvider;
+import com.adif.elcanomovil.domain.repositories.logos.LogosInfoRepository;
+import com.adif.elcanomovil.domain.usecases.logos.ManageLogosUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideManageLogosUseCaseFactory implements Factory<ManageLogosUseCase> {
+    private final Provider<LogoProvider> logoProvider;
+    private final Provider<LogosInfoRepository> logosInfoRepositoryProvider;
+
+    public UseCases_ProvideManageLogosUseCaseFactory(Provider<LogosInfoRepository> provider, Provider<LogoProvider> provider2) {
+        this.logosInfoRepositoryProvider = provider;
+        this.logoProvider = provider2;
+    }
+
+    public static UseCases_ProvideManageLogosUseCaseFactory create(Provider<LogosInfoRepository> provider, Provider<LogoProvider> provider2) {
+        return new UseCases_ProvideManageLogosUseCaseFactory(provider, provider2);
+    }
+
+    public static ManageLogosUseCase provideManageLogosUseCase(LogosInfoRepository logosInfoRepository, LogoProvider logoProvider) {
+        return (ManageLogosUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideManageLogosUseCase(logosInfoRepository, logoProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public ManageLogosUseCase get() {
+        return provideManageLogosUseCase(this.logosInfoRepositoryProvider.get(), this.logoProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideModifySubscriptionsdUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.subscriptions.SubscriptionRepository;
+import com.adif.elcanomovil.domain.usecases.subscriptions.subscriptions.ModifySubscriptionsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideModifySubscriptionsdUseCaseFactory implements Factory<ModifySubscriptionsUseCase> {
+    private final Provider<SubscriptionRepository> subscriptionRepositoryProvider;
+
+    public UseCases_ProvideModifySubscriptionsdUseCaseFactory(Provider<SubscriptionRepository> provider) {
+        this.subscriptionRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideModifySubscriptionsdUseCaseFactory create(Provider<SubscriptionRepository> provider) {
+        return new UseCases_ProvideModifySubscriptionsdUseCaseFactory(provider);
+    }
+
+    public static ModifySubscriptionsUseCase provideModifySubscriptionsdUseCase(SubscriptionRepository subscriptionRepository) {
+        return (ModifySubscriptionsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideModifySubscriptionsdUseCase(subscriptionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public ModifySubscriptionsUseCase get() {
+        return provideModifySubscriptionsdUseCase(this.subscriptionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideMuteSubscriptionsdUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.subscriptions.SubscriptionRepository;
+import com.adif.elcanomovil.domain.usecases.subscriptions.subscriptions.MuteSubscriptionsUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideMuteSubscriptionsdUseCaseFactory implements Factory<MuteSubscriptionsUseCase> {
+    private final Provider<SubscriptionRepository> subscriptionRepositoryProvider;
+
+    public UseCases_ProvideMuteSubscriptionsdUseCaseFactory(Provider<SubscriptionRepository> provider) {
+        this.subscriptionRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideMuteSubscriptionsdUseCaseFactory create(Provider<SubscriptionRepository> provider) {
+        return new UseCases_ProvideMuteSubscriptionsdUseCaseFactory(provider);
+    }
+
+    public static MuteSubscriptionsUseCase provideMuteSubscriptionsdUseCase(SubscriptionRepository subscriptionRepository) {
+        return (MuteSubscriptionsUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideMuteSubscriptionsdUseCase(subscriptionRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public MuteSubscriptionsUseCase get() {
+        return provideMuteSubscriptionsdUseCase(this.subscriptionRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideRefreshAvisaUserUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.avisa.AvisaLoginRepository;
+import com.adif.elcanomovil.domain.usecases.avisa.user.RefreshAvisaUserUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideRefreshAvisaUserUseCaseFactory implements Factory<RefreshAvisaUserUseCase> {
+    private final Provider<AvisaLoginRepository> avisaLoginRepositoryProvider;
+
+    public UseCases_ProvideRefreshAvisaUserUseCaseFactory(Provider<AvisaLoginRepository> provider) {
+        this.avisaLoginRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideRefreshAvisaUserUseCaseFactory create(Provider<AvisaLoginRepository> provider) {
+        return new UseCases_ProvideRefreshAvisaUserUseCaseFactory(provider);
+    }
+
+    public static RefreshAvisaUserUseCase provideRefreshAvisaUserUseCase(AvisaLoginRepository avisaLoginRepository) {
+        return (RefreshAvisaUserUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideRefreshAvisaUserUseCase(avisaLoginRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public RefreshAvisaUserUseCase get() {
+        return provideRefreshAvisaUserUseCase(this.avisaLoginRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideRegisterAvisaUserUseCaseFactory.java

@@ -0,0 +1,50 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.providers.PushIdTokenProvider;
+import com.adif.elcanomovil.domain.providers.TokenJwtProvider;
+import com.adif.elcanomovil.domain.repositories.avisa.AvisaLoginRepository;
+import com.adif.elcanomovil.domain.usecases.avisa.user.RegisterAvisaUserUseCase;
+import com.adif.elcanomovil.domain.usecases.credentials.GeneratePasswordUseCase;
+import com.adif.elcanomovil.domain.usecases.credentials.GeneratePersistentUserIdUseCase;
+import com.adif.elcanomovil.domain.usecases.credentials.GenerateUserIdUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideRegisterAvisaUserUseCaseFactory implements Factory<RegisterAvisaUserUseCase> {
+    private final Provider<AvisaLoginRepository> avisaLoginRepositoryProvider;
+    private final Provider<GeneratePasswordUseCase> generatePasswordUseCaseProvider;
+    private final Provider<GeneratePersistentUserIdUseCase> generateSubscriptionUserIdUseCaseProvider;
+    private final Provider<GenerateUserIdUseCase> generateUserIdUseCaseProvider;
+    private final Provider<PushIdTokenProvider> pushIdTokenProvider;
+    private final Provider<TokenJwtProvider> tokenProvider;
+
+    public UseCases_ProvideRegisterAvisaUserUseCaseFactory(Provider<AvisaLoginRepository> provider, Provider<GeneratePasswordUseCase> provider2, Provider<GenerateUserIdUseCase> provider3, Provider<GeneratePersistentUserIdUseCase> provider4, Provider<PushIdTokenProvider> provider5, Provider<TokenJwtProvider> provider6) {
+        this.avisaLoginRepositoryProvider = provider;
+        this.generatePasswordUseCaseProvider = provider2;
+        this.generateUserIdUseCaseProvider = provider3;
+        this.generateSubscriptionUserIdUseCaseProvider = provider4;
+        this.pushIdTokenProvider = provider5;
+        this.tokenProvider = provider6;
+    }
+
+    public static UseCases_ProvideRegisterAvisaUserUseCaseFactory create(Provider<AvisaLoginRepository> provider, Provider<GeneratePasswordUseCase> provider2, Provider<GenerateUserIdUseCase> provider3, Provider<GeneratePersistentUserIdUseCase> provider4, Provider<PushIdTokenProvider> provider5, Provider<TokenJwtProvider> provider6) {
+        return new UseCases_ProvideRegisterAvisaUserUseCaseFactory(provider, provider2, provider3, provider4, provider5, provider6);
+    }
+
+    public static RegisterAvisaUserUseCase provideRegisterAvisaUserUseCase(AvisaLoginRepository avisaLoginRepository, GeneratePasswordUseCase generatePasswordUseCase, GenerateUserIdUseCase generateUserIdUseCase, GeneratePersistentUserIdUseCase generatePersistentUserIdUseCase, PushIdTokenProvider pushIdTokenProvider, TokenJwtProvider tokenJwtProvider) {
+        return (RegisterAvisaUserUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideRegisterAvisaUserUseCase(avisaLoginRepository, generatePasswordUseCase, generateUserIdUseCase, generatePersistentUserIdUseCase, pushIdTokenProvider, tokenJwtProvider));
+    }
+
+    @Override // javax.inject.Provider
+    public RegisterAvisaUserUseCase get() {
+        return provideRegisterAvisaUserUseCase(this.avisaLoginRepositoryProvider.get(), this.generatePasswordUseCaseProvider.get(), this.generateUserIdUseCaseProvider.get(), this.generateSubscriptionUserIdUseCaseProvider.get(), this.pushIdTokenProvider.get(), this.tokenProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideRemoveFavoriteStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.RemoveFavoriteStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideRemoveFavoriteStationUseCaseFactory implements Factory<RemoveFavoriteStationUseCase> {
+    private final Provider<FavoritesRepository> favoriteRepositoryProvider;
+
+    public UseCases_ProvideRemoveFavoriteStationUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.favoriteRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideRemoveFavoriteStationUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideRemoveFavoriteStationUseCaseFactory(provider);
+    }
+
+    public static RemoveFavoriteStationUseCase provideRemoveFavoriteStationUseCase(FavoritesRepository favoritesRepository) {
+        return (RemoveFavoriteStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideRemoveFavoriteStationUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public RemoveFavoriteStationUseCase get() {
+        return provideRemoveFavoriteStationUseCase(this.favoriteRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideRemoveFavoriteTrainUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.RemoveFavoriteTrainUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideRemoveFavoriteTrainUseCaseFactory implements Factory<RemoveFavoriteTrainUseCase> {
+    private final Provider<FavoritesRepository> favoriteRepositoryProvider;
+
+    public UseCases_ProvideRemoveFavoriteTrainUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.favoriteRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideRemoveFavoriteTrainUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideRemoveFavoriteTrainUseCaseFactory(provider);
+    }
+
+    public static RemoveFavoriteTrainUseCase provideRemoveFavoriteTrainUseCase(FavoritesRepository favoritesRepository) {
+        return (RemoveFavoriteTrainUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideRemoveFavoriteTrainUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public RemoveFavoriteTrainUseCase get() {
+        return provideRemoveFavoriteTrainUseCase(this.favoriteRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSaveFavoriteStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.SaveFavoriteStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSaveFavoriteStationUseCaseFactory implements Factory<SaveFavoriteStationUseCase> {
+    private final Provider<FavoritesRepository> favoriteRepositoryProvider;
+
+    public UseCases_ProvideSaveFavoriteStationUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.favoriteRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSaveFavoriteStationUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideSaveFavoriteStationUseCaseFactory(provider);
+    }
+
+    public static SaveFavoriteStationUseCase provideSaveFavoriteStationUseCase(FavoritesRepository favoritesRepository) {
+        return (SaveFavoriteStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSaveFavoriteStationUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SaveFavoriteStationUseCase get() {
+        return provideSaveFavoriteStationUseCase(this.favoriteRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSaveFavoriteTrainUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.favourites.FavoritesRepository;
+import com.adif.elcanomovil.domain.usecases.favorites.SaveFavoriteTrainUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSaveFavoriteTrainUseCaseFactory implements Factory<SaveFavoriteTrainUseCase> {
+    private final Provider<FavoritesRepository> favoriteRepositoryProvider;
+
+    public UseCases_ProvideSaveFavoriteTrainUseCaseFactory(Provider<FavoritesRepository> provider) {
+        this.favoriteRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSaveFavoriteTrainUseCaseFactory create(Provider<FavoritesRepository> provider) {
+        return new UseCases_ProvideSaveFavoriteTrainUseCaseFactory(provider);
+    }
+
+    public static SaveFavoriteTrainUseCase provideSaveFavoriteTrainUseCase(FavoritesRepository favoritesRepository) {
+        return (SaveFavoriteTrainUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSaveFavoriteTrainUseCase(favoritesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SaveFavoriteTrainUseCase get() {
+        return provideSaveFavoriteTrainUseCase(this.favoriteRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSaveFilterUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.filters.FiltersRepository;
+import com.adif.elcanomovil.domain.usecases.filters.SaveFilterUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSaveFilterUseCaseFactory implements Factory<SaveFilterUseCase> {
+    private final Provider<FiltersRepository> filtersRepositoryProvider;
+
+    public UseCases_ProvideSaveFilterUseCaseFactory(Provider<FiltersRepository> provider) {
+        this.filtersRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSaveFilterUseCaseFactory create(Provider<FiltersRepository> provider) {
+        return new UseCases_ProvideSaveFilterUseCaseFactory(provider);
+    }
+
+    public static SaveFilterUseCase provideSaveFilterUseCase(FiltersRepository filtersRepository) {
+        return (SaveFilterUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSaveFilterUseCase(filtersRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SaveFilterUseCase get() {
+        return provideSaveFilterUseCase(this.filtersRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSaveRecentSearchUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.searches.SearchesRepository;
+import com.adif.elcanomovil.domain.usecases.recentSearch.SaveRecentSearchUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSaveRecentSearchUseCaseFactory implements Factory<SaveRecentSearchUseCase> {
+    private final Provider<SearchesRepository> searchesRepositoryProvider;
+
+    public UseCases_ProvideSaveRecentSearchUseCaseFactory(Provider<SearchesRepository> provider) {
+        this.searchesRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSaveRecentSearchUseCaseFactory create(Provider<SearchesRepository> provider) {
+        return new UseCases_ProvideSaveRecentSearchUseCaseFactory(provider);
+    }
+
+    public static SaveRecentSearchUseCase provideSaveRecentSearchUseCase(SearchesRepository searchesRepository) {
+        return (SaveRecentSearchUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSaveRecentSearchUseCase(searchesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SaveRecentSearchUseCase get() {
+        return provideSaveRecentSearchUseCase(this.searchesRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSaveRecentTrainSearchUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.searches.SearchesRepository;
+import com.adif.elcanomovil.domain.usecases.recentSearch.SaveRecentTrainSearchUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSaveRecentTrainSearchUseCaseFactory implements Factory<SaveRecentTrainSearchUseCase> {
+    private final Provider<SearchesRepository> searchesRepositoryProvider;
+
+    public UseCases_ProvideSaveRecentTrainSearchUseCaseFactory(Provider<SearchesRepository> provider) {
+        this.searchesRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSaveRecentTrainSearchUseCaseFactory create(Provider<SearchesRepository> provider) {
+        return new UseCases_ProvideSaveRecentTrainSearchUseCaseFactory(provider);
+    }
+
+    public static SaveRecentTrainSearchUseCase provideSaveRecentTrainSearchUseCase(SearchesRepository searchesRepository) {
+        return (SaveRecentTrainSearchUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSaveRecentTrainSearchUseCase(searchesRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SaveRecentTrainSearchUseCase get() {
+        return provideSaveRecentTrainSearchUseCase(this.searchesRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSetHomeStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.SetHomeStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSetHomeStationUseCaseFactory implements Factory<SetHomeStationUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideSetHomeStationUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSetHomeStationUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideSetHomeStationUseCaseFactory(provider);
+    }
+
+    public static SetHomeStationUseCase provideSetHomeStationUseCase(StationsRepository stationsRepository) {
+        return (SetHomeStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSetHomeStationUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SetHomeStationUseCase get() {
+        return provideSetHomeStationUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSetLastDepartureTypeTrainIsCercaniasUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.SetLastDepartureTypeTrainIsCercaniasUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSetLastDepartureTypeTrainIsCercaniasUseCaseFactory implements Factory<SetLastDepartureTypeTrainIsCercaniasUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideSetLastDepartureTypeTrainIsCercaniasUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSetLastDepartureTypeTrainIsCercaniasUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideSetLastDepartureTypeTrainIsCercaniasUseCaseFactory(provider);
+    }
+
+    public static SetLastDepartureTypeTrainIsCercaniasUseCase provideSetLastDepartureTypeTrainIsCercaniasUseCase(CirculationRepository circulationRepository) {
+        return (SetLastDepartureTypeTrainIsCercaniasUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSetLastDepartureTypeTrainIsCercaniasUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SetLastDepartureTypeTrainIsCercaniasUseCase get() {
+        return provideSetLastDepartureTypeTrainIsCercaniasUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSetLastDeparturesArrivalsStationToUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.SetLastDeparturesArrivalsStationToUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSetLastDeparturesArrivalsStationToUseCaseFactory implements Factory<SetLastDeparturesArrivalsStationToUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideSetLastDeparturesArrivalsStationToUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSetLastDeparturesArrivalsStationToUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideSetLastDeparturesArrivalsStationToUseCaseFactory(provider);
+    }
+
+    public static SetLastDeparturesArrivalsStationToUseCase provideSetLastDeparturesArrivalsStationToUseCase(CirculationRepository circulationRepository) {
+        return (SetLastDeparturesArrivalsStationToUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSetLastDeparturesArrivalsStationToUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SetLastDeparturesArrivalsStationToUseCase get() {
+        return provideSetLastDeparturesArrivalsStationToUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSetLastDeparturesArrivalsStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.SetLastDeparturesArrivalsStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSetLastDeparturesArrivalsStationUseCaseFactory implements Factory<SetLastDeparturesArrivalsStationUseCase> {
+    private final Provider<CirculationRepository> circulationRepositoryProvider;
+
+    public UseCases_ProvideSetLastDeparturesArrivalsStationUseCaseFactory(Provider<CirculationRepository> provider) {
+        this.circulationRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSetLastDeparturesArrivalsStationUseCaseFactory create(Provider<CirculationRepository> provider) {
+        return new UseCases_ProvideSetLastDeparturesArrivalsStationUseCaseFactory(provider);
+    }
+
+    public static SetLastDeparturesArrivalsStationUseCase provideSetLastDeparturesArrivalsStationUseCase(CirculationRepository circulationRepository) {
+        return (SetLastDeparturesArrivalsStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSetLastDeparturesArrivalsStationUseCase(circulationRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SetLastDeparturesArrivalsStationUseCase get() {
+        return provideSetLastDeparturesArrivalsStationUseCase(this.circulationRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSetLastVisitedStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.SetLastVisitedStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSetLastVisitedStationUseCaseFactory implements Factory<SetLastVisitedStationUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideSetLastVisitedStationUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSetLastVisitedStationUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideSetLastVisitedStationUseCaseFactory(provider);
+    }
+
+    public static SetLastVisitedStationUseCase provideSetLastVisitedStationUseCase(StationsRepository stationsRepository) {
+        return (SetLastVisitedStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSetLastVisitedStationUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SetLastVisitedStationUseCase get() {
+        return provideSetLastVisitedStationUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideSetWorkStationUseCaseFactory.java

@@ -0,0 +1,35 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.repositories.stations.StationsRepository;
+import com.adif.elcanomovil.domain.usecases.stations.SetWorkStationUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideSetWorkStationUseCaseFactory implements Factory<SetWorkStationUseCase> {
+    private final Provider<StationsRepository> stationsRepositoryProvider;
+
+    public UseCases_ProvideSetWorkStationUseCaseFactory(Provider<StationsRepository> provider) {
+        this.stationsRepositoryProvider = provider;
+    }
+
+    public static UseCases_ProvideSetWorkStationUseCaseFactory create(Provider<StationsRepository> provider) {
+        return new UseCases_ProvideSetWorkStationUseCaseFactory(provider);
+    }
+
+    public static SetWorkStationUseCase provideSetWorkStationUseCase(StationsRepository stationsRepository) {
+        return (SetWorkStationUseCase) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideSetWorkStationUseCase(stationsRepository));
+    }
+
+    @Override // javax.inject.Provider
+    public SetWorkStationUseCase get() {
+        return provideSetWorkStationUseCase(this.stationsRepositoryProvider.get());
+    }
+}

apk_decompiled/sources/com/adif/elcanomovil/di/UseCases_ProvideTabDataHolderFactory.java

@@ -0,0 +1,28 @@
+package com.adif.elcanomovil.di;
+
+import com.adif.elcanomovil.domain.usecases.tabs.TabDataHolder;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import g1.g;
+
+@ScopeMetadata("javax.inject.Singleton")
+@DaggerGenerated
+@QualifierMetadata
+/* loaded from: classes.dex */
+public final class UseCases_ProvideTabDataHolderFactory implements Factory<TabDataHolder> {
+    public static UseCases_ProvideTabDataHolderFactory create() {
+        return g.f6742a;
+    }
+
+    public static TabDataHolder provideTabDataHolder() {
+        return (TabDataHolder) Preconditions.checkNotNullFromProvides(UseCases.INSTANCE.provideTabDataHolder());
+    }
+
+    @Override // javax.inject.Provider
+    public TabDataHolder get() {
+        return provideTabDataHolder();
+    }
+}