@cryptorobot.ai/client 1.26.0-dev.1030 → 1.26.0-dev.1031

package/lib/src/services/models/presets/presets.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { ModelsPreset, ModelsPresetData, ModelsPresetPatch, ModelsPresetQuery } from './presets.schema';
 export type { ModelsPreset, ModelsPresetData, ModelsPresetPatch, ModelsPresetQuery };
 export interface ModelsPresetsParams extends MongoDBAdapterParams<ModelsPresetQuery> {
     user?: any;
 }
-export declare class ModelsPresetsService<ServiceParams extends Params = ModelsPresetsParams> extends FlexibleMongoDBService<ModelsPreset, ModelsPresetData, ModelsPresetsParams, ModelsPresetPatch> {
+export declare class ModelsPresetsService<ServiceParams extends Params = ModelsPresetsParams> extends MongoDBService<ModelsPreset, ModelsPresetData, ModelsPresetsParams, ModelsPresetPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/models/signals/history/history.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../../declarations';
 import type { ModelsSignalsHistory, ModelsSignalsHistoryData, ModelsSignalsHistoryPatch, ModelsSignalsHistoryQuery } from './history.schema';
 export type { ModelsSignalsHistory, ModelsSignalsHistoryData, ModelsSignalsHistoryPatch, ModelsSignalsHistoryQuery };
 export interface ModelsSignalsHistoryParams extends MongoDBAdapterParams<ModelsSignalsHistoryQuery> {
 }
-export declare class ModelsSignalsHistoryService<ServiceParams extends Params = ModelsSignalsHistoryParams> extends FlexibleMongoDBService<ModelsSignalsHistory, ModelsSignalsHistoryData, ModelsSignalsHistoryParams, ModelsSignalsHistoryPatch> {
+export declare class ModelsSignalsHistoryService<ServiceParams extends Params = ModelsSignalsHistoryParams> extends MongoDBService<ModelsSignalsHistory, ModelsSignalsHistoryData, ModelsSignalsHistoryParams, ModelsSignalsHistoryPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/models/signals/signals.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { ModelsSignals, ModelsSignalsData, ModelsSignalsPatch, ModelsSignalsQuery } from './signals.schema';
 export type { ModelsSignals, ModelsSignalsData, ModelsSignalsPatch, ModelsSignalsQuery };
 export interface ModelsSignalsParams extends MongoDBAdapterParams<ModelsSignalsQuery> {
     user?: any;
 }
-export declare class ModelsSignalsService<ServiceParams extends Params = ModelsSignalsParams> extends FlexibleMongoDBService<ModelsSignals, ModelsSignalsData, ModelsSignalsParams, ModelsSignalsPatch> {
+export declare class ModelsSignalsService<ServiceParams extends Params = ModelsSignalsParams> extends MongoDBService<ModelsSignals, ModelsSignalsData, ModelsSignalsParams, ModelsSignalsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/models/signals/subscriptions/subscriptions.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../../declarations';
 import type { ModelsSignalsSubscriptions, ModelsSignalsSubscriptionsData, ModelsSignalsSubscriptionsPatch, ModelsSignalsSubscriptionsQuery } from './subscriptions.schema';
 export type { ModelsSignalsSubscriptions, ModelsSignalsSubscriptionsData, ModelsSignalsSubscriptionsPatch, ModelsSignalsSubscriptionsQuery };
 export interface ModelsSignalsSubscriptionsParams extends MongoDBAdapterParams<ModelsSignalsSubscriptionsQuery> {
 }
-export declare class ModelsSignalsSubscriptionsService<ServiceParams extends Params = ModelsSignalsSubscriptionsParams> extends FlexibleMongoDBService<ModelsSignalsSubscriptions, ModelsSignalsSubscriptionsData, ModelsSignalsSubscriptionsParams, ModelsSignalsSubscriptionsPatch> {
+export declare class ModelsSignalsSubscriptionsService<ServiceParams extends Params = ModelsSignalsSubscriptionsParams> extends MongoDBService<ModelsSignalsSubscriptions, ModelsSignalsSubscriptionsData, ModelsSignalsSubscriptionsParams, ModelsSignalsSubscriptionsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/objectives/objectives.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../declarations';
 import type { Objectives, ObjectivesData, ObjectivesPatch, ObjectivesQuery } from './objectives.schema';
 export type { Objectives, ObjectivesData, ObjectivesPatch, ObjectivesQuery };
 export interface ObjectivesParams extends MongoDBAdapterParams<ObjectivesQuery> {
 }
-export declare class ObjectivesService<ServiceParams extends Params = ObjectivesParams> extends FlexibleMongoDBService<Objectives, ObjectivesData, ObjectivesParams, ObjectivesPatch> {
+export declare class ObjectivesService<ServiceParams extends Params = ObjectivesParams> extends MongoDBService<Objectives, ObjectivesData, ObjectivesParams, ObjectivesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/referrals/referrals.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../declarations';
 import type { Referrals, ReferralsData, ReferralsPatch, ReferralsQuery } from './referrals.schema';
 export type { Referrals, ReferralsData, ReferralsPatch, ReferralsQuery };
 export interface ReferralsParams extends MongoDBAdapterParams<ReferralsQuery> {
 }
-export declare class ReferralsService<ServiceParams extends Params = ReferralsParams> extends FlexibleMongoDBService<Referrals, ReferralsData, ReferralsParams, ReferralsPatch> {
+export declare class ReferralsService<ServiceParams extends Params = ReferralsParams> extends MongoDBService<Referrals, ReferralsData, ReferralsParams, ReferralsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/security/events/security-events.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { SecurityEvents, SecurityEventsData, SecurityEventsPatch, SecurityEventsQuery } from './security-events.schema';
 export type { SecurityEvents, SecurityEventsData, SecurityEventsPatch, SecurityEventsQuery };
 export interface SecurityEventsParams extends MongoDBAdapterParams<SecurityEventsQuery> {
 }
-export declare class SecurityEventsService<ServiceParams extends Params = SecurityEventsParams> extends FlexibleMongoDBService<SecurityEvents, SecurityEventsData, SecurityEventsParams, SecurityEventsPatch> {
+export declare class SecurityEventsService<ServiceParams extends Params = SecurityEventsParams> extends MongoDBService<SecurityEvents, SecurityEventsData, SecurityEventsParams, SecurityEventsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/series/balance/balance.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { SeriesBalance, SeriesBalanceData, SeriesBalancePatch, SeriesBalanceQuery } from './balance.schema';
 export type { SeriesBalance, SeriesBalanceData, SeriesBalancePatch, SeriesBalanceQuery };
 export interface SeriesBalanceParams extends MongoDBAdapterParams<SeriesBalanceQuery> {
 }
-export declare class SeriesBalanceService<ServiceParams extends Params = SeriesBalanceParams> extends FlexibleMongoDBService<SeriesBalance, SeriesBalanceData, SeriesBalanceParams, SeriesBalancePatch> {
+export declare class SeriesBalanceService<ServiceParams extends Params = SeriesBalanceParams> extends MongoDBService<SeriesBalance, SeriesBalanceData, SeriesBalanceParams, SeriesBalancePatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/series/performance/performance.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { SeriesPerformance, SeriesPerformanceData, SeriesPerformancePatch, SeriesPerformanceQuery } from './performance.schema';
 export type { SeriesPerformance, SeriesPerformanceData, SeriesPerformancePatch, SeriesPerformanceQuery };
 export interface SeriesPerformanceParams extends MongoDBAdapterParams<SeriesPerformanceQuery> {
 }
-export declare class SeriesPerformanceService<ServiceParams extends Params = SeriesPerformanceParams> extends FlexibleMongoDBService<SeriesPerformance, SeriesPerformanceData, SeriesPerformanceParams, SeriesPerformancePatch> {
+export declare class SeriesPerformanceService<ServiceParams extends Params = SeriesPerformanceParams> extends MongoDBService<SeriesPerformance, SeriesPerformanceData, SeriesPerformanceParams, SeriesPerformancePatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/snapshot/snapshot.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../declarations';
 import type { Snapshot, SnapshotData, SnapshotPatch, SnapshotQuery } from './snapshot.schema';
 export type { Snapshot, SnapshotData, SnapshotPatch, SnapshotQuery };
 export interface SnapshotParams extends MongoDBAdapterParams<SnapshotQuery> {
 }
-export declare class SnapshotService<ServiceParams extends Params = SnapshotParams> extends FlexibleMongoDBService<Snapshot, SnapshotData, SnapshotParams, SnapshotPatch> {
+export declare class SnapshotService<ServiceParams extends Params = SnapshotParams> extends MongoDBService<Snapshot, SnapshotData, SnapshotParams, SnapshotPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/store/items/items.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StoreItems, StoreItemsData, StoreItemsPatch, StoreItemsQuery } from './items.schema';
 export type { StoreItems, StoreItemsData, StoreItemsPatch, StoreItemsQuery };
 export interface StoreItemsParams extends MongoDBAdapterParams<StoreItemsQuery> {
     user?: any;
 }
-export declare class StoreItemsService<ServiceParams extends Params = StoreItemsParams> extends FlexibleMongoDBService<StoreItems, StoreItemsData, StoreItemsParams, StoreItemsPatch> {
+export declare class StoreItemsService<ServiceParams extends Params = StoreItemsParams> extends MongoDBService<StoreItems, StoreItemsData, StoreItemsParams, StoreItemsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/ai/ai.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesAi, StrategiesAiData, StrategiesAiPatch, StrategiesAiQuery } from './ai.schema';
 export type { StrategiesAi, StrategiesAiData, StrategiesAiPatch, StrategiesAiQuery };
 export interface StrategiesAiParams extends MongoDBAdapterParams<StrategiesAiQuery> {
     user?: any;
 }
-export declare class StrategiesAiService<ServiceParams extends Params = StrategiesAiParams> extends FlexibleMongoDBService<StrategiesAi, StrategiesAiData, StrategiesAiParams, StrategiesAiPatch> {
+export declare class StrategiesAiService<ServiceParams extends Params = StrategiesAiParams> extends MongoDBService<StrategiesAi, StrategiesAiData, StrategiesAiParams, StrategiesAiPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/backtest/backtest.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesBacktest, StrategiesBacktestData, StrategiesBacktestPatch, StrategiesBacktestQuery } from './backtest.schema';
 export type { StrategiesBacktest, StrategiesBacktestData, StrategiesBacktestPatch, StrategiesBacktestQuery };
 export interface StrategiesBacktestParams extends MongoDBAdapterParams<StrategiesBacktestQuery> {
     user?: any;
 }
-export declare class StrategiesBacktestService<ServiceParams extends Params = StrategiesBacktestParams> extends FlexibleMongoDBService<StrategiesBacktest, StrategiesBacktestData, StrategiesBacktestParams, StrategiesBacktestPatch> {
+export declare class StrategiesBacktestService<ServiceParams extends Params = StrategiesBacktestParams> extends MongoDBService<StrategiesBacktest, StrategiesBacktestData, StrategiesBacktestParams, StrategiesBacktestPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/backtest/results/results.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../../declarations';
 import type { StrategiesBacktestResults, StrategiesBacktestResultsData, StrategiesBacktestResultsPatch, StrategiesBacktestResultsQuery } from './results.schema';
 export type { StrategiesBacktestResults, StrategiesBacktestResultsData, StrategiesBacktestResultsPatch, StrategiesBacktestResultsQuery };
 export interface StrategiesBacktestResultsParams extends MongoDBAdapterParams<StrategiesBacktestResultsQuery> {
 }
-export declare class StrategiesBacktestResultsService<ServiceParams extends Params = StrategiesBacktestResultsParams> extends FlexibleMongoDBService<StrategiesBacktestResults, StrategiesBacktestResultsData, StrategiesBacktestResultsParams, StrategiesBacktestResultsPatch> {
+export declare class StrategiesBacktestResultsService<ServiceParams extends Params = StrategiesBacktestResultsParams> extends MongoDBService<StrategiesBacktestResults, StrategiesBacktestResultsData, StrategiesBacktestResultsParams, StrategiesBacktestResultsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/follow/follow.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesFollow, StrategiesFollowData, StrategiesFollowPatch, StrategiesFollowQuery } from './follow.schema';
 export type { StrategiesFollow, StrategiesFollowData, StrategiesFollowPatch, StrategiesFollowQuery };
 export interface StrategiesFollowParams extends MongoDBAdapterParams<StrategiesFollowQuery> {
     user?: any;
 }
-export declare class StrategiesFollowService<ServiceParams extends Params = StrategiesFollowParams> extends FlexibleMongoDBService<StrategiesFollow, StrategiesFollowData, StrategiesFollowParams, StrategiesFollowPatch> {
+export declare class StrategiesFollowService<ServiceParams extends Params = StrategiesFollowParams> extends MongoDBService<StrategiesFollow, StrategiesFollowData, StrategiesFollowParams, StrategiesFollowPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/generate/generate.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesGenerate, StrategiesGenerateData, StrategiesGeneratePatch, StrategiesGenerateQuery } from './generate.schema';
 export type { StrategiesGenerate, StrategiesGenerateData, StrategiesGeneratePatch, StrategiesGenerateQuery };
 export interface StrategiesGenerateParams extends MongoDBAdapterParams<StrategiesGenerateQuery> {
     user?: any;
 }
-export declare class StrategiesGenerateService<ServiceParams extends Params = StrategiesGenerateParams> extends FlexibleMongoDBService<StrategiesGenerate, StrategiesGenerateData, StrategiesGenerateParams, StrategiesGeneratePatch> {
+export declare class StrategiesGenerateService<ServiceParams extends Params = StrategiesGenerateParams> extends MongoDBService<StrategiesGenerate, StrategiesGenerateData, StrategiesGenerateParams, StrategiesGeneratePatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/history/history.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesHistory, StrategiesHistoryData, StrategiesHistoryPatch, StrategiesHistoryQuery } from './history.schema';
 export type { StrategiesHistory, StrategiesHistoryData, StrategiesHistoryPatch, StrategiesHistoryQuery };
 export interface StrategiesHistoryParams extends MongoDBAdapterParams<StrategiesHistoryQuery> {
 }
-export declare class StrategiesHistoryService<ServiceParams extends Params = StrategiesHistoryParams> extends FlexibleMongoDBService<StrategiesHistory, StrategiesHistoryData, StrategiesHistoryParams, StrategiesHistoryPatch> {
+export declare class StrategiesHistoryService<ServiceParams extends Params = StrategiesHistoryParams> extends MongoDBService<StrategiesHistory, StrategiesHistoryData, StrategiesHistoryParams, StrategiesHistoryPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/hyperopt/hyperopt.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesHyperopt, StrategiesHyperoptData, StrategiesHyperoptPatch, StrategiesHyperoptQuery } from './hyperopt.schema';
 export type { StrategiesHyperopt, StrategiesHyperoptData, StrategiesHyperoptPatch, StrategiesHyperoptQuery };
 export interface StrategiesHyperoptParams extends MongoDBAdapterParams<StrategiesHyperoptQuery> {
     user?: any;
 }
-export declare class StrategiesHyperoptService<ServiceParams extends Params = StrategiesHyperoptParams> extends FlexibleMongoDBService<StrategiesHyperopt, StrategiesHyperoptData, StrategiesHyperoptParams, StrategiesHyperoptPatch> {
+export declare class StrategiesHyperoptService<ServiceParams extends Params = StrategiesHyperoptParams> extends MongoDBService<StrategiesHyperopt, StrategiesHyperoptData, StrategiesHyperoptParams, StrategiesHyperoptPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/indicators/indicators.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesIndicators, StrategiesIndicatorsData, StrategiesIndicatorsPatch, StrategiesIndicatorsQuery } from './indicators.schema';
 export type { StrategiesIndicators, StrategiesIndicatorsData, StrategiesIndicatorsPatch, StrategiesIndicatorsQuery };
 export interface StrategiesIndicatorsParams extends MongoDBAdapterParams<StrategiesIndicatorsQuery> {
 }
-export declare class StrategiesIndicatorsService<ServiceParams extends Params = StrategiesIndicatorsParams> extends FlexibleMongoDBService<StrategiesIndicators, StrategiesIndicatorsData, StrategiesIndicatorsParams, StrategiesIndicatorsPatch> {
+export declare class StrategiesIndicatorsService<ServiceParams extends Params = StrategiesIndicatorsParams> extends MongoDBService<StrategiesIndicators, StrategiesIndicatorsData, StrategiesIndicatorsParams, StrategiesIndicatorsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/indicators/talib/talib.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../../declarations';
 import type { StrategiesIndicatorsTalib, StrategiesIndicatorsTalibData, StrategiesIndicatorsTalibPatch, StrategiesIndicatorsTalibQuery } from './talib.schema';
 export type { StrategiesIndicatorsTalib, StrategiesIndicatorsTalibData, StrategiesIndicatorsTalibPatch, StrategiesIndicatorsTalibQuery };
 export interface StrategiesIndicatorsTalibParams extends MongoDBAdapterParams<StrategiesIndicatorsTalibQuery> {
 }
-export declare class StrategiesIndicatorsTalibService<ServiceParams extends Params = StrategiesIndicatorsTalibParams> extends FlexibleMongoDBService<StrategiesIndicatorsTalib, StrategiesIndicatorsTalibData, StrategiesIndicatorsTalibParams, StrategiesIndicatorsTalibPatch> {
+export declare class StrategiesIndicatorsTalibService<ServiceParams extends Params = StrategiesIndicatorsTalibParams> extends MongoDBService<StrategiesIndicatorsTalib, StrategiesIndicatorsTalibData, StrategiesIndicatorsTalibParams, StrategiesIndicatorsTalibPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/research/research.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesResearch, StrategiesResearchData, StrategiesResearchPatch, StrategiesResearchQuery } from './research.schema';
 export type { StrategiesResearch, StrategiesResearchData, StrategiesResearchPatch, StrategiesResearchQuery };
 export interface StrategiesResearchParams extends MongoDBAdapterParams<StrategiesResearchQuery> {
 }
-export declare class StrategiesResearchService<ServiceParams extends Params = StrategiesResearchParams> extends FlexibleMongoDBService<StrategiesResearch, StrategiesResearchData, StrategiesResearchParams, StrategiesResearchPatch> {
+export declare class StrategiesResearchService<ServiceParams extends Params = StrategiesResearchParams> extends MongoDBService<StrategiesResearch, StrategiesResearchData, StrategiesResearchParams, StrategiesResearchPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/strategies.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../declarations';
 import type { Strategies, StrategiesData, StrategiesPatch, StrategiesQuery } from './strategies.schema';
 export type { Strategies, StrategiesData, StrategiesPatch, StrategiesQuery };
 export interface StrategiesParams extends MongoDBAdapterParams<StrategiesQuery> {
     user?: any;
 }
-export declare class StrategiesService<ServiceParams extends Params = StrategiesParams> extends FlexibleMongoDBService<Strategies, StrategiesData, StrategiesParams, StrategiesPatch> {
+export declare class StrategiesService<ServiceParams extends Params = StrategiesParams> extends MongoDBService<Strategies, StrategiesData, StrategiesParams, StrategiesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/strategies/templates/templates.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { StrategiesTemplates, StrategiesTemplatesData, StrategiesTemplatesPatch, StrategiesTemplatesQuery } from './templates.schema';
 export type { StrategiesTemplates, StrategiesTemplatesData, StrategiesTemplatesPatch, StrategiesTemplatesQuery };
 export interface StrategiesTemplatesParams extends MongoDBAdapterParams<StrategiesTemplatesQuery> {
 }
-export declare class StrategiesTemplatesService<ServiceParams extends Params = StrategiesTemplatesParams> extends FlexibleMongoDBService<StrategiesTemplates, StrategiesTemplatesData, StrategiesTemplatesParams, StrategiesTemplatesPatch> {
+export declare class StrategiesTemplatesService<ServiceParams extends Params = StrategiesTemplatesParams> extends MongoDBService<StrategiesTemplates, StrategiesTemplatesData, StrategiesTemplatesParams, StrategiesTemplatesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/tasks/comments/comments.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { TasksComments, TasksCommentsData, TasksCommentsPatch, TasksCommentsQuery } from './comments.schema';
 export type { TasksComments, TasksCommentsData, TasksCommentsPatch, TasksCommentsQuery };
 export interface TasksCommentsParams extends MongoDBAdapterParams<TasksCommentsQuery> {
 }
-export declare class TasksCommentsService<ServiceParams extends Params = TasksCommentsParams> extends FlexibleMongoDBService<TasksComments, TasksCommentsData, TasksCommentsParams, TasksCommentsPatch> {
+export declare class TasksCommentsService<ServiceParams extends Params = TasksCommentsParams> extends MongoDBService<TasksComments, TasksCommentsData, TasksCommentsParams, TasksCommentsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/tasks/tasks.class.d.ts

@@ -1,13 +1,13 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../declarations';
 import type { Tasks, TasksData, TasksPatch, TasksQuery } from './tasks.schema';
 export type { Tasks, TasksData, TasksPatch, TasksQuery };
 export interface TasksParams extends MongoDBAdapterParams<TasksQuery> {
     user?: any;
 }
-export declare class TasksService<ServiceParams extends Params = TasksParams> extends FlexibleMongoDBService<Tasks, TasksData, TasksParams, TasksPatch> {
+export declare class TasksService<ServiceParams extends Params = TasksParams> extends MongoDBService<Tasks, TasksData, TasksParams, TasksPatch> {
     setup(): Promise<void>;
     private ensureIndexes;
 }

package/lib/src/services/tax/research/research.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { TaxResearch, TaxResearchData, TaxResearchPatch, TaxResearchQuery } from './research.schema';
 export type { TaxResearch, TaxResearchData, TaxResearchPatch, TaxResearchQuery };
 export interface TaxResearchParams extends MongoDBAdapterParams<TaxResearchQuery> {
 }
-export declare class TaxResearchService<ServiceParams extends Params = TaxResearchParams> extends FlexibleMongoDBService<TaxResearch, TaxResearchData, TaxResearchParams, TaxResearchPatch> {
+export declare class TaxResearchService<ServiceParams extends Params = TaxResearchParams> extends MongoDBService<TaxResearch, TaxResearchData, TaxResearchParams, TaxResearchPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/tax/sessions/conversations/conversations.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../../declarations';
 import type { TaxSessionsConversations, TaxSessionsConversationsData, TaxSessionsConversationsPatch, TaxSessionsConversationsQuery } from './conversations.schema';
 export type { TaxSessionsConversations, TaxSessionsConversationsData, TaxSessionsConversationsPatch, TaxSessionsConversationsQuery };
 export interface TaxSessionsConversationsParams extends MongoDBAdapterParams<TaxSessionsConversationsQuery> {
     user?: any;
 }
-export declare class TaxSessionsConversationsService<ServiceParams extends Params = TaxSessionsConversationsParams> extends FlexibleMongoDBService<TaxSessionsConversations, TaxSessionsConversationsData, TaxSessionsConversationsParams, TaxSessionsConversationsPatch> {
+export declare class TaxSessionsConversationsService<ServiceParams extends Params = TaxSessionsConversationsParams> extends MongoDBService<TaxSessionsConversations, TaxSessionsConversationsData, TaxSessionsConversationsParams, TaxSessionsConversationsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/tax/sessions/sessions.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { TaxSessions, TaxSessionsData, TaxSessionsPatch, TaxSessionsQuery } from './sessions.schema';
 export type { TaxSessions, TaxSessionsData, TaxSessionsPatch, TaxSessionsQuery };
 export interface TaxSessionsParams extends MongoDBAdapterParams<TaxSessionsQuery> {
     user?: any;
 }
-export declare class TaxSessionsService<ServiceParams extends Params = TaxSessionsParams> extends FlexibleMongoDBService<TaxSessions, TaxSessionsData, TaxSessionsParams, TaxSessionsPatch> {
+export declare class TaxSessionsService<ServiceParams extends Params = TaxSessionsParams> extends MongoDBService<TaxSessions, TaxSessionsData, TaxSessionsParams, TaxSessionsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/tokens/tokens.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../declarations';
 import type { Tokens, TokensData, TokensPatch, TokensQuery } from './tokens.schema';
 export type { Tokens, TokensData, TokensPatch, TokensQuery };
 export interface TokensParams extends MongoDBAdapterParams<TokensQuery> {
 }
-export declare class TokensService<ServiceParams extends Params = TokensParams> extends FlexibleMongoDBService<Tokens, TokensData, TokensParams, TokensPatch> {
+export declare class TokensService<ServiceParams extends Params = TokensParams> extends MongoDBService<Tokens, TokensData, TokensParams, TokensPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/traders/pods/api/api.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../../declarations';
 import type { TradersPodsApi, TradersPodsApiData, TradersPodsApiPatch, TradersPodsApiQuery } from './api.schema';
 export type { TradersPodsApi, TradersPodsApiData, TradersPodsApiPatch, TradersPodsApiQuery };
 export interface TradersPodsApiParams extends MongoDBAdapterParams<TradersPodsApiQuery> {
     user?: any;
 }
-export declare class TradersPodsApiService<ServiceParams extends Params = TradersPodsApiParams> extends FlexibleMongoDBService<TradersPodsApi, TradersPodsApiData, TradersPodsApiParams, TradersPodsApiPatch> {
+export declare class TradersPodsApiService<ServiceParams extends Params = TradersPodsApiParams> extends MongoDBService<TradersPodsApi, TradersPodsApiData, TradersPodsApiParams, TradersPodsApiPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/traders/pods/events/events.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../../declarations';
 import type { TradersPodsEvents, TradersPodsEventsData, TradersPodsEventsPatch, TradersPodsEventsQuery } from './events.schema';
 export type { TradersPodsEvents, TradersPodsEventsData, TradersPodsEventsPatch, TradersPodsEventsQuery };
 export interface TradersPodsEventsParams extends MongoDBAdapterParams<TradersPodsEventsQuery> {
 }
-export declare class TradersPodsEventsService<ServiceParams extends Params = TradersPodsEventsParams> extends FlexibleMongoDBService<TradersPodsEvents, TradersPodsEventsData, TradersPodsEventsParams, TradersPodsEventsPatch> {
+export declare class TradersPodsEventsService<ServiceParams extends Params = TradersPodsEventsParams> extends MongoDBService<TradersPodsEvents, TradersPodsEventsData, TradersPodsEventsParams, TradersPodsEventsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/traders/pods/pods.class.d.ts

@@ -1,12 +1,12 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { TradersPods, TradersPodsData, TradersPodsPatch, TradersPodsQuery } from './pods.schema';
 export type { TradersPods, TradersPodsData, TradersPodsPatch, TradersPodsQuery };
 export interface TradersPodsParams extends MongoDBAdapterParams<TradersPodsQuery> {
     user?: any;
 }
-export declare class TradersPodsService<ServiceParams extends Params = TradersPodsParams> extends FlexibleMongoDBService<TradersPods, TradersPodsData, TradersPodsParams, TradersPodsPatch> {
+export declare class TradersPodsService<ServiceParams extends Params = TradersPodsParams> extends MongoDBService<TradersPods, TradersPodsData, TradersPodsParams, TradersPodsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/traders/pods/webhooks/webhooks.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../../declarations';
 import type { TradersPodsWebhooks, TradersPodsWebhooksData, TradersPodsWebhooksPatch, TradersPodsWebhooksQuery } from './webhooks.schema';
 export type { TradersPodsWebhooks, TradersPodsWebhooksData, TradersPodsWebhooksPatch, TradersPodsWebhooksQuery };
 export interface TradersPodsWebhooksParams extends MongoDBAdapterParams<TradersPodsWebhooksQuery> {
 }
-export declare class TradersPodsWebhooksService<ServiceParams extends Params = TradersPodsWebhooksParams> extends FlexibleMongoDBService<TradersPodsWebhooks, TradersPodsWebhooksData, TradersPodsWebhooksParams, TradersPodsWebhooksPatch> {
+export declare class TradersPodsWebhooksService<ServiceParams extends Params = TradersPodsWebhooksParams> extends MongoDBService<TradersPodsWebhooks, TradersPodsWebhooksData, TradersPodsWebhooksParams, TradersPodsWebhooksPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/traders/traders.class.d.ts

@@ -1,8 +1,8 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
 import { MemoryService } from '@feathersjs/memory';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../declarations';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
 import type { Traders, TradersData, TradersPatch, TradersQuery } from './traders.schema';
 export type { Traders, TradersData, TradersPatch, TradersQuery };
 export interface TradersParams extends MongoDBAdapterParams<TradersQuery> {
@@ -11,7 +11,7 @@ export interface TradersParams extends MongoDBAdapterParams<TradersQuery> {
 }
 export interface TradersParamsMemory {
 }
-export declare class TradersService<ServiceParams extends Params = TradersParams> extends FlexibleMongoDBService<Traders, TradersData, TradersParams, TradersPatch> {
+export declare class TradersService<ServiceParams extends Params = TradersParams> extends MongoDBService<Traders, TradersData, TradersParams, TradersPatch> {
 }
 export declare class TradersServiceMemory<ServiceParams extends Params = TradersParamsMemory> extends MemoryService<Traders, TradersData, TradersParamsMemory, TradersPatch> {
 }

package/lib/src/services/trades/trades.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../declarations';
 import type { Trades, TradesData, TradesPatch, TradesQuery } from './trades.schema';
 export type { Trades, TradesData, TradesPatch, TradesQuery };
 export interface TradesParams extends MongoDBAdapterParams<TradesQuery> {
 }
-export declare class TradesService<ServiceParams extends Params = TradesParams> extends FlexibleMongoDBService<Trades, TradesData, TradesParams, TradesPatch> {
+export declare class TradesService<ServiceParams extends Params = TradesParams> extends MongoDBService<Trades, TradesData, TradesParams, TradesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/users/access/access.class.d.ts

@@ -1,11 +1,11 @@
 import type { Params } from '@feathersjs/feathers';
 import type { MongoDBAdapterOptions, MongoDBAdapterParams } from '@feathersjs/mongodb';
-import { FlexibleMongoDBService } from '../../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import type { Application } from '../../../declarations';
 import type { UsersAccess, UsersAccessData, UsersAccessPatch, UsersAccessQuery } from './access.schema';
 export type { UsersAccess, UsersAccessData, UsersAccessPatch, UsersAccessQuery };
 export interface UsersAccessParams extends MongoDBAdapterParams<UsersAccessQuery> {
 }
-export declare class UsersAccessService<ServiceParams extends Params = UsersAccessParams> extends FlexibleMongoDBService<UsersAccess, UsersAccessData, UsersAccessParams, UsersAccessPatch> {
+export declare class UsersAccessService<ServiceParams extends Params = UsersAccessParams> extends MongoDBService<UsersAccess, UsersAccessData, UsersAccessParams, UsersAccessPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;