Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

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();
+    }
+}