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

package/lib/src/services/blog/sitemaps/sitemaps.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 { BlogSitemaps, BlogSitemapsData, BlogSitemapsPatch, BlogSitemapsQuery } from './sitemaps.schema';
 export type { BlogSitemaps, BlogSitemapsData, BlogSitemapsPatch, BlogSitemapsQuery };
 export interface BlogSitemapsParams extends MongoDBAdapterParams<BlogSitemapsQuery> {
 }
-export declare class BlogSitemapsService<ServiceParams extends Params = BlogSitemapsParams> extends FlexibleMongoDBService<BlogSitemaps, BlogSitemapsData, BlogSitemapsParams, BlogSitemapsPatch> {
+export declare class BlogSitemapsService<ServiceParams extends Params = BlogSitemapsParams> extends MongoDBService<BlogSitemaps, BlogSitemapsData, BlogSitemapsParams, BlogSitemapsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/blog/suggestions/suggestions.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 { BlogSuggestions, BlogSuggestionsData, BlogSuggestionsPatch, BlogSuggestionsQuery } from './suggestions.schema';
 export type { BlogSuggestions, BlogSuggestionsData, BlogSuggestionsPatch, BlogSuggestionsQuery };
 export interface BlogSuggestionsParams extends MongoDBAdapterParams<BlogSuggestionsQuery> {
 }
-export declare class BlogSuggestionsService<ServiceParams extends Params = BlogSuggestionsParams> extends FlexibleMongoDBService<BlogSuggestions, BlogSuggestionsData, BlogSuggestionsParams, BlogSuggestionsPatch> {
+export declare class BlogSuggestionsService<ServiceParams extends Params = BlogSuggestionsParams> extends MongoDBService<BlogSuggestions, BlogSuggestionsData, BlogSuggestionsParams, BlogSuggestionsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

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

@@ -1,6 +1,6 @@
 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';
 type Config = any;
 type ConfigData = any;
@@ -9,6 +9,6 @@ type ConfigQuery = any;
 export type { Config, ConfigData, ConfigPatch, ConfigQuery };
 export interface ConfigParams extends MongoDBAdapterParams<ConfigQuery> {
 }
-export declare class ConfigService<ServiceParams extends Params = ConfigParams> extends FlexibleMongoDBService<Config, ConfigData, ConfigParams, ConfigPatch> {
+export declare class ConfigService<ServiceParams extends Params = ConfigParams> extends MongoDBService<Config, ConfigData, ConfigParams, ConfigPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/copilot/concerns/concerns.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 { CopilotConcerns, CopilotConcernsData, CopilotConcernsPatch, CopilotConcernsQuery } from './concerns.schema';
 export type { CopilotConcerns, CopilotConcernsData, CopilotConcernsPatch, CopilotConcernsQuery };
 export interface CopilotConcernsParams extends MongoDBAdapterParams<CopilotConcernsQuery> {
 }
-export declare class CopilotConcernsService<ServiceParams extends Params = CopilotConcernsParams> extends FlexibleMongoDBService<CopilotConcerns, CopilotConcernsData, CopilotConcernsParams, CopilotConcernsPatch> {
+export declare class CopilotConcernsService<ServiceParams extends Params = CopilotConcernsParams> extends MongoDBService<CopilotConcerns, CopilotConcernsData, CopilotConcernsParams, CopilotConcernsPatch> {
     setup(): Promise<void>;
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/copilot/decisions/decisions.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 { CopilotDecisions, CopilotDecisionsData, CopilotDecisionsPatch, CopilotDecisionsQuery } from './decisions.schema';
 export type { CopilotDecisions, CopilotDecisionsData, CopilotDecisionsPatch, CopilotDecisionsQuery };
 export interface CopilotDecisionsParams extends MongoDBAdapterParams<CopilotDecisionsQuery> {
 }
-export declare class CopilotDecisionsService<ServiceParams extends Params = CopilotDecisionsParams> extends FlexibleMongoDBService<CopilotDecisions, CopilotDecisionsData, CopilotDecisionsParams, CopilotDecisionsPatch> {
+export declare class CopilotDecisionsService<ServiceParams extends Params = CopilotDecisionsParams> extends MongoDBService<CopilotDecisions, CopilotDecisionsData, CopilotDecisionsParams, CopilotDecisionsPatch> {
     setup(): Promise<void>;
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/copilot/recommendations/recommendations.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 { CopilotRecommendations, CopilotRecommendationsData, CopilotRecommendationsPatch, CopilotRecommendationsQuery } from './recommendations.schema';
 export type { CopilotRecommendations, CopilotRecommendationsData, CopilotRecommendationsPatch, CopilotRecommendationsQuery };
 export interface CopilotRecommendationsParams extends MongoDBAdapterParams<CopilotRecommendationsQuery> {
 }
-export declare class CopilotRecommendationsService<ServiceParams extends Params = CopilotRecommendationsParams> extends FlexibleMongoDBService<CopilotRecommendations, CopilotRecommendationsData, CopilotRecommendationsParams, CopilotRecommendationsPatch> {
+export declare class CopilotRecommendationsService<ServiceParams extends Params = CopilotRecommendationsParams> extends MongoDBService<CopilotRecommendations, CopilotRecommendationsData, CopilotRecommendationsParams, CopilotRecommendationsPatch> {
     setup(): Promise<void>;
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/currencies/currencies.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 { Currencies, CurrenciesData, CurrenciesPatch, CurrenciesQuery } from './currencies.schema';
 export type { Currencies, CurrenciesData, CurrenciesPatch, CurrenciesQuery };
 export interface CurrenciesParams extends MongoDBAdapterParams<CurrenciesQuery> {
 }
-export declare class CurrenciesService<ServiceParams extends Params = CurrenciesParams> extends FlexibleMongoDBService<Currencies, CurrenciesData, CurrenciesParams, CurrenciesPatch> {
+export declare class CurrenciesService<ServiceParams extends Params = CurrenciesParams> extends MongoDBService<Currencies, CurrenciesData, CurrenciesParams, CurrenciesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/emails/emails.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 { Emails, EmailsData, EmailsPatch, EmailsQuery } from './emails.schema';
 export type { Emails, EmailsData, EmailsPatch, EmailsQuery };
 export interface EmailsParams extends MongoDBAdapterParams<EmailsQuery> {
 }
-export declare class EmailsService<ServiceParams extends Params = EmailsParams> extends FlexibleMongoDBService<Emails, EmailsData, EmailsParams, EmailsPatch> {
+export declare class EmailsService<ServiceParams extends Params = EmailsParams> extends MongoDBService<Emails, EmailsData, EmailsParams, EmailsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/events/events.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 { Events, EventsData, EventsPatch, EventsQuery } from './events.schema';
 export type { Events, EventsData, EventsPatch, EventsQuery };
 export interface EventsParams extends MongoDBAdapterParams<EventsQuery> {
     user?: any;
 }
-export declare class EventsService<ServiceParams extends Params = EventsParams> extends FlexibleMongoDBService<Events, EventsData, EventsParams, EventsPatch> {
+export declare class EventsService<ServiceParams extends Params = EventsParams> extends MongoDBService<Events, EventsData, EventsParams, EventsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/events/triggers/triggers.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 { EventsTriggers, EventsTriggersData, EventsTriggersPatch, EventsTriggersQuery } from './triggers.schema';
 export type { EventsTriggers, EventsTriggersData, EventsTriggersPatch, EventsTriggersQuery };
 export interface EventsTriggersParams extends MongoDBAdapterParams<EventsTriggersQuery> {
     user?: any;
 }
-export declare class EventsTriggersService<ServiceParams extends Params = EventsTriggersParams> extends FlexibleMongoDBService<EventsTriggers, EventsTriggersData, EventsTriggersParams, EventsTriggersPatch> {
+export declare class EventsTriggersService<ServiceParams extends Params = EventsTriggersParams> extends MongoDBService<EventsTriggers, EventsTriggersData, EventsTriggersParams, EventsTriggersPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/events/types/types.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 { EventsTypes, EventsTypesData, EventsTypesPatch, EventsTypesQuery } from './types.schema';
 export type { EventsTypes, EventsTypesData, EventsTypesPatch, EventsTypesQuery };
 export interface EventsTypesParams extends MongoDBAdapterParams<EventsTypesQuery> {
     user?: any;
 }
-export declare class EventsTypesService<ServiceParams extends Params = EventsTypesParams> extends FlexibleMongoDBService<EventsTypes, EventsTypesData, EventsTypesParams, EventsTypesPatch> {
+export declare class EventsTypesService<ServiceParams extends Params = EventsTypesParams> extends MongoDBService<EventsTypes, EventsTypesData, EventsTypesParams, EventsTypesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/balance/balance.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 { ExchangesBalance, ExchangesBalanceData, ExchangesBalancePatch, ExchangesBalanceQuery } from './balance.schema';
 export type { ExchangesBalance, ExchangesBalanceData, ExchangesBalancePatch, ExchangesBalanceQuery };
 export interface ExchangesBalanceParams extends MongoDBAdapterParams<ExchangesBalanceQuery> {
     user?: any;
 }
-export declare class ExchangesBalanceService<ServiceParams extends Params = ExchangesBalanceParams> extends FlexibleMongoDBService<ExchangesBalance, ExchangesBalanceData, ExchangesBalanceParams, ExchangesBalancePatch> {
+export declare class ExchangesBalanceService<ServiceParams extends Params = ExchangesBalanceParams> extends MongoDBService<ExchangesBalance, ExchangesBalanceData, ExchangesBalanceParams, ExchangesBalancePatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/deposits/deposits.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 { ExchangesDeposits, ExchangesDepositsData, ExchangesDepositsPatch, ExchangesDepositsQuery } from './deposits.schema';
 export type { ExchangesDeposits, ExchangesDepositsData, ExchangesDepositsPatch, ExchangesDepositsQuery };
 export interface ExchangesDepositsParams extends MongoDBAdapterParams<ExchangesDepositsQuery> {
 }
-export declare class ExchangesDepositsService<ServiceParams extends Params = ExchangesDepositsParams> extends FlexibleMongoDBService<ExchangesDeposits, ExchangesDepositsData, ExchangesDepositsParams, ExchangesDepositsPatch> {
+export declare class ExchangesDepositsService<ServiceParams extends Params = ExchangesDepositsParams> extends MongoDBService<ExchangesDeposits, ExchangesDepositsData, ExchangesDepositsParams, ExchangesDepositsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/deposits/sync/sync.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 { ExchangesDepositsSync, ExchangesDepositsSyncData, ExchangesDepositsSyncPatch, ExchangesDepositsSyncQuery } from './sync.schema';
 export type { ExchangesDepositsSync, ExchangesDepositsSyncData, ExchangesDepositsSyncPatch, ExchangesDepositsSyncQuery };
 export interface ExchangesDepositsSyncParams extends MongoDBAdapterParams<ExchangesDepositsSyncQuery> {
 }
-export declare class ExchangesDepositsSyncService<ServiceParams extends Params = ExchangesDepositsSyncParams> extends FlexibleMongoDBService<ExchangesDepositsSync, ExchangesDepositsSyncData, ExchangesDepositsSyncParams, ExchangesDepositsSyncPatch> {
+export declare class ExchangesDepositsSyncService<ServiceParams extends Params = ExchangesDepositsSyncParams> extends MongoDBService<ExchangesDepositsSync, ExchangesDepositsSyncData, ExchangesDepositsSyncParams, ExchangesDepositsSyncPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/download/download.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 { ExchangesDownload, ExchangesDownloadData, ExchangesDownloadPatch, ExchangesDownloadQuery } from './download.schema';
 export type { ExchangesDownload, ExchangesDownloadData, ExchangesDownloadPatch, ExchangesDownloadQuery };
 export interface ExchangesDownloadParams extends MongoDBAdapterParams<ExchangesDownloadQuery> {
     user?: any;
 }
-export declare class ExchangesDownloadService<ServiceParams extends Params = ExchangesDownloadParams> extends FlexibleMongoDBService<ExchangesDownload, ExchangesDownloadData, ExchangesDownloadParams, ExchangesDownloadPatch> {
+export declare class ExchangesDownloadService<ServiceParams extends Params = ExchangesDownloadParams> extends MongoDBService<ExchangesDownload, ExchangesDownloadData, ExchangesDownloadParams, ExchangesDownloadPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/download/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 { ExchangesDownloadWebhooks, ExchangesDownloadWebhooksData, ExchangesDownloadWebhooksPatch, ExchangesDownloadWebhooksQuery } from './webhooks.schema';
 export type { ExchangesDownloadWebhooks, ExchangesDownloadWebhooksData, ExchangesDownloadWebhooksPatch, ExchangesDownloadWebhooksQuery };
 export interface ExchangesDownloadWebhooksParams extends MongoDBAdapterParams<ExchangesDownloadWebhooksQuery> {
 }
-export declare class ExchangesDownloadWebhooksService<ServiceParams extends Params = ExchangesDownloadWebhooksParams> extends FlexibleMongoDBService<ExchangesDownloadWebhooks, ExchangesDownloadWebhooksData, ExchangesDownloadWebhooksParams, ExchangesDownloadWebhooksPatch> {
+export declare class ExchangesDownloadWebhooksService<ServiceParams extends Params = ExchangesDownloadWebhooksParams> extends MongoDBService<ExchangesDownloadWebhooks, ExchangesDownloadWebhooksData, ExchangesDownloadWebhooksParams, ExchangesDownloadWebhooksPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/exchanges.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 { Exchanges, ExchangesData, ExchangesPatch, ExchangesQuery } from './exchanges.schema';
 export type { Exchanges, ExchangesData, ExchangesPatch, ExchangesQuery };
 export interface ExchangesParams extends MongoDBAdapterParams<ExchangesQuery> {
     user?: any;
 }
-export declare class ExchangesService<ServiceParams extends Params = ExchangesParams> extends FlexibleMongoDBService<Exchanges, ExchangesData, ExchangesParams, ExchangesPatch> {
+export declare class ExchangesService<ServiceParams extends Params = ExchangesParams> extends MongoDBService<Exchanges, ExchangesData, ExchangesParams, ExchangesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/ledger/ledger.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 { ExchangesLedger, ExchangesLedgerData, ExchangesLedgerPatch, ExchangesLedgerQuery } from './ledger.schema';
 export type { ExchangesLedger, ExchangesLedgerData, ExchangesLedgerPatch, ExchangesLedgerQuery };
 export interface ExchangesLedgerParams extends MongoDBAdapterParams<ExchangesLedgerQuery> {
 }
-export declare class ExchangesLedgerService<ServiceParams extends Params = ExchangesLedgerParams> extends FlexibleMongoDBService<ExchangesLedger, ExchangesLedgerData, ExchangesLedgerParams, ExchangesLedgerPatch> {
+export declare class ExchangesLedgerService<ServiceParams extends Params = ExchangesLedgerParams> extends MongoDBService<ExchangesLedger, ExchangesLedgerData, ExchangesLedgerParams, ExchangesLedgerPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/ledger/sync/sync.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 { ExchangesLedgerSync, ExchangesLedgerSyncData, ExchangesLedgerSyncPatch, ExchangesLedgerSyncQuery } from './sync.schema';
 export type { ExchangesLedgerSync, ExchangesLedgerSyncData, ExchangesLedgerSyncPatch, ExchangesLedgerSyncQuery };
 export interface ExchangesLedgerSyncParams extends MongoDBAdapterParams<ExchangesLedgerSyncQuery> {
 }
-export declare class ExchangesLedgerSyncService<ServiceParams extends Params = ExchangesLedgerSyncParams> extends FlexibleMongoDBService<ExchangesLedgerSync, ExchangesLedgerSyncData, ExchangesLedgerSyncParams, ExchangesLedgerSyncPatch> {
+export declare class ExchangesLedgerSyncService<ServiceParams extends Params = ExchangesLedgerSyncParams> extends MongoDBService<ExchangesLedgerSync, ExchangesLedgerSyncData, ExchangesLedgerSyncParams, ExchangesLedgerSyncPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/ohlcv/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 { ExchangesOhlcvHistory, ExchangesOhlcvHistoryData, ExchangesOhlcvHistoryPatch, ExchangesOhlcvHistoryQuery } from './history.schema';
 export type { ExchangesOhlcvHistory, ExchangesOhlcvHistoryData, ExchangesOhlcvHistoryPatch, ExchangesOhlcvHistoryQuery };
 export interface ExchangesOhlcvHistoryParams extends MongoDBAdapterParams<ExchangesOhlcvHistoryQuery> {
 }
-export declare class ExchangesOhlcvHistoryService<ServiceParams extends Params = ExchangesOhlcvHistoryParams> extends FlexibleMongoDBService<ExchangesOhlcvHistory, ExchangesOhlcvHistoryData, ExchangesOhlcvHistoryParams, ExchangesOhlcvHistoryPatch> {
+export declare class ExchangesOhlcvHistoryService<ServiceParams extends Params = ExchangesOhlcvHistoryParams> extends MongoDBService<ExchangesOhlcvHistory, ExchangesOhlcvHistoryData, ExchangesOhlcvHistoryParams, ExchangesOhlcvHistoryPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/ticker/ticker.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 { ExchangesTicker, ExchangesTickerData, ExchangesTickerPatch, ExchangesTickerQuery } from './ticker.schema';
 export type { ExchangesTicker, ExchangesTickerData, ExchangesTickerPatch, ExchangesTickerQuery };
 export interface ExchangesTickerParams extends MongoDBAdapterParams<ExchangesTickerQuery> {
     user?: any;
 }
-export declare class ExchangesTickerService<ServiceParams extends Params = ExchangesTickerParams> extends FlexibleMongoDBService<ExchangesTicker, ExchangesTickerData, ExchangesTickerParams, ExchangesTickerPatch> {
+export declare class ExchangesTickerService<ServiceParams extends Params = ExchangesTickerParams> extends MongoDBService<ExchangesTicker, ExchangesTickerData, ExchangesTickerParams, ExchangesTickerPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/transactions/sync/sync.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 { ExchangesTransactionsSync, ExchangesTransactionsSyncData, ExchangesTransactionsSyncPatch, ExchangesTransactionsSyncQuery } from './sync.schema';
 export type { ExchangesTransactionsSync, ExchangesTransactionsSyncData, ExchangesTransactionsSyncPatch, ExchangesTransactionsSyncQuery };
 export interface ExchangesTransactionsSyncParams extends MongoDBAdapterParams<ExchangesTransactionsSyncQuery> {
 }
-export declare class ExchangesTransactionsSyncService<ServiceParams extends Params = ExchangesTransactionsSyncParams> extends FlexibleMongoDBService<ExchangesTransactionsSync, ExchangesTransactionsSyncData, ExchangesTransactionsSyncParams, ExchangesTransactionsSyncPatch> {
+export declare class ExchangesTransactionsSyncService<ServiceParams extends Params = ExchangesTransactionsSyncParams> extends MongoDBService<ExchangesTransactionsSync, ExchangesTransactionsSyncData, ExchangesTransactionsSyncParams, ExchangesTransactionsSyncPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/exchanges/transactions/transactions.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 { ExchangesTransactions, ExchangesTransactionsData, ExchangesTransactionsPatch, ExchangesTransactionsQuery } from './transactions.schema';
 export type { ExchangesTransactions, ExchangesTransactionsData, ExchangesTransactionsPatch, ExchangesTransactionsQuery };
 export interface ExchangesTransactionsParams extends MongoDBAdapterParams<ExchangesTransactionsQuery> {
 }
-export declare class ExchangesTransactionsService<ServiceParams extends Params = ExchangesTransactionsParams> extends FlexibleMongoDBService<ExchangesTransactions, ExchangesTransactionsData, ExchangesTransactionsParams, ExchangesTransactionsPatch> {
+export declare class ExchangesTransactionsService<ServiceParams extends Params = ExchangesTransactionsParams> extends MongoDBService<ExchangesTransactions, ExchangesTransactionsData, ExchangesTransactionsParams, ExchangesTransactionsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/extensions/extensions.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 { Extensions, ExtensionsData, ExtensionsPatch, ExtensionsQuery } from './extensions.schema';
 export type { Extensions, ExtensionsData, ExtensionsPatch, ExtensionsQuery };
 export interface ExtensionsParams extends MongoDBAdapterParams<ExtensionsQuery> {
     user?: any;
 }
-export declare class ExtensionsService<ServiceParams extends Params = ExtensionsParams> extends FlexibleMongoDBService<Extensions, ExtensionsData, ExtensionsParams, ExtensionsPatch> {
+export declare class ExtensionsService<ServiceParams extends Params = ExtensionsParams> extends MongoDBService<Extensions, ExtensionsData, ExtensionsParams, ExtensionsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/insights/crypto-stress-index/crypto-stress-index.class.d.ts

@@ -1,6 +1,6 @@
 import type { Id, 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 { InsightsCryptoStressIndex, InsightsCryptoStressIndexData, InsightsCryptoStressIndexPatch, InsightsCryptoStressIndexQuery } from './crypto-stress-index.schema';
 export type { InsightsCryptoStressIndex, InsightsCryptoStressIndexData, InsightsCryptoStressIndexPatch, InsightsCryptoStressIndexQuery };
@@ -24,7 +24,7 @@ export interface ConfirmedStressResponse {
     blockEntries: boolean;
     exitMode: 'none' | 'exit_losers' | 'exit_all';
 }
-export declare class InsightsCryptoStressIndexService<ServiceParams extends Params = InsightsCryptoStressIndexParams> extends FlexibleMongoDBService<InsightsCryptoStressIndex, InsightsCryptoStressIndexData, InsightsCryptoStressIndexParams, InsightsCryptoStressIndexPatch> {
+export declare class InsightsCryptoStressIndexService<ServiceParams extends Params = InsightsCryptoStressIndexParams> extends MongoDBService<InsightsCryptoStressIndex, InsightsCryptoStressIndexData, InsightsCryptoStressIndexParams, InsightsCryptoStressIndexPatch> {
     private _emaScore;
     private _confirmedBand;
     private _pendingBand;

package/lib/src/services/insights/etf-flow/etf-flow.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 { InsightsEtfFlow, InsightsEtfFlowData, InsightsEtfFlowPatch, InsightsEtfFlowQuery } from './etf-flow.schema';
 export type { InsightsEtfFlow, InsightsEtfFlowData, InsightsEtfFlowPatch, InsightsEtfFlowQuery };
 export interface InsightsEtfFlowParams extends MongoDBAdapterParams<InsightsEtfFlowQuery> {
 }
-export declare class InsightsEtfFlowService<ServiceParams extends Params = InsightsEtfFlowParams> extends FlexibleMongoDBService<InsightsEtfFlow, InsightsEtfFlowData, InsightsEtfFlowParams, InsightsEtfFlowPatch> {
+export declare class InsightsEtfFlowService<ServiceParams extends Params = InsightsEtfFlowParams> extends MongoDBService<InsightsEtfFlow, InsightsEtfFlowData, InsightsEtfFlowParams, InsightsEtfFlowPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/insights/fear-and-greed/fear-and-greed.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 { InsightsFearAndGreed, InsightsFearAndGreedData, InsightsFearAndGreedPatch, InsightsFearAndGreedQuery } from './fear-and-greed.schema';
 export type { InsightsFearAndGreed, InsightsFearAndGreedData, InsightsFearAndGreedPatch, InsightsFearAndGreedQuery };
 export interface InsightsFearAndGreedParams extends MongoDBAdapterParams<InsightsFearAndGreedQuery> {
 }
-export declare class InsightsFearAndGreedService<ServiceParams extends Params = InsightsFearAndGreedParams> extends FlexibleMongoDBService<InsightsFearAndGreed, InsightsFearAndGreedData, InsightsFearAndGreedParams, InsightsFearAndGreedPatch> {
+export declare class InsightsFearAndGreedService<ServiceParams extends Params = InsightsFearAndGreedParams> extends MongoDBService<InsightsFearAndGreed, InsightsFearAndGreedData, InsightsFearAndGreedParams, InsightsFearAndGreedPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/insights/global/global.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 { InsightsGlobal, InsightsGlobalData, InsightsGlobalPatch, InsightsGlobalQuery } from './global.schema';
 export type { InsightsGlobal, InsightsGlobalData, InsightsGlobalPatch, InsightsGlobalQuery };
 export interface InsightsGlobalParams extends MongoDBAdapterParams<InsightsGlobalQuery> {
 }
-export declare class InsightsGlobalService<ServiceParams extends Params = InsightsGlobalParams> extends FlexibleMongoDBService<InsightsGlobal, InsightsGlobalData, InsightsGlobalParams, InsightsGlobalPatch> {
+export declare class InsightsGlobalService<ServiceParams extends Params = InsightsGlobalParams> extends MongoDBService<InsightsGlobal, InsightsGlobalData, InsightsGlobalParams, InsightsGlobalPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/insights/insights.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 { Insights, InsightsData, InsightsPatch, InsightsQuery } from './insights.schema';
 export type { Insights, InsightsData, InsightsPatch, InsightsQuery };
 export interface InsightsParams extends MongoDBAdapterParams<InsightsQuery> {
 }
-export declare class InsightsService<ServiceParams extends Params = InsightsParams> extends FlexibleMongoDBService<Insights, InsightsData, InsightsParams, InsightsPatch> {
+export declare class InsightsService<ServiceParams extends Params = InsightsParams> extends MongoDBService<Insights, InsightsData, InsightsParams, InsightsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/insights/news/news.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 { InsightsNews, InsightsNewsData, InsightsNewsPatch, InsightsNewsQuery } from './news.schema';
 export type { InsightsNews, InsightsNewsData, InsightsNewsPatch, InsightsNewsQuery };
 export interface InsightsNewsParams extends MongoDBAdapterParams<InsightsNewsQuery> {
 }
-export declare class InsightsNewsService<ServiceParams extends Params = InsightsNewsParams> extends FlexibleMongoDBService<InsightsNews, InsightsNewsData, InsightsNewsParams, InsightsNewsPatch> {
+export declare class InsightsNewsService<ServiceParams extends Params = InsightsNewsParams> extends MongoDBService<InsightsNews, InsightsNewsData, InsightsNewsParams, InsightsNewsPatch> {
     upsert(data: {
         newsType: string;
         newsItems: any[];

package/lib/src/services/keys/KeysService.d.ts

@@ -1,8 +1,8 @@
 import type { Params } from '@feathersjs/feathers';
-import { FlexibleMongoDBService } from '../../helpers/flexible-objectid';
+import { MongoDBService } from '@feathersjs/mongodb';
 import { KeysParams } from './keys.class';
 import type { Keys, KeysData, KeysPatch } from './keys.schema';
-export declare class KeysService<ServiceParams extends Params = KeysParams> extends FlexibleMongoDBService<Keys, KeysData, KeysParams, KeysPatch> {
+export declare class KeysService<ServiceParams extends Params = KeysParams> extends MongoDBService<Keys, KeysData, KeysParams, KeysPatch> {
     constructor(options: any);
     create(data: KeysData & {
         _rawApiKey?: string;

package/lib/src/services/keys/keys.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 { Keys, KeysData, KeysPatch, KeysQuery } from './keys.schema';
 export type { Keys, KeysData, KeysPatch, KeysQuery };
 export interface KeysParams extends MongoDBAdapterParams<KeysQuery> {
     user?: any;
 }
-export declare class KeysService<ServiceParams extends Params = KeysParams> extends FlexibleMongoDBService<Keys, KeysData, KeysParams, KeysPatch> {
+export declare class KeysService<ServiceParams extends Params = KeysParams> extends MongoDBService<Keys, KeysData, KeysParams, KeysPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

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

@@ -1,6 +1,6 @@
 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';
 type Marketplaces = any;
 type MarketplacesData = any;
@@ -9,6 +9,6 @@ type MarketplacesQuery = any;
 export type { Marketplaces, MarketplacesData, MarketplacesPatch, MarketplacesQuery };
 export interface MarketplacesParams extends MongoDBAdapterParams<MarketplacesQuery> {
 }
-export declare class MarketplacesService<ServiceParams extends Params = MarketplacesParams> extends FlexibleMongoDBService<Marketplaces, MarketplacesData, MarketplacesParams, MarketplacesPatch> {
+export declare class MarketplacesService<ServiceParams extends Params = MarketplacesParams> extends MongoDBService<Marketplaces, MarketplacesData, MarketplacesParams, MarketplacesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/markets/markets.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 { Markets, MarketsData, MarketsPatch, MarketsQuery } from './markets.schema';
 export type { Markets, MarketsData, MarketsPatch, MarketsQuery };
 export interface MarketsParams extends MongoDBAdapterParams<MarketsQuery> {
 }
-export declare class MarketsService<ServiceParams extends Params = MarketsParams> extends FlexibleMongoDBService<Markets, MarketsData, MarketsParams, MarketsPatch> {
+export declare class MarketsService<ServiceParams extends Params = MarketsParams> extends MongoDBService<Markets, MarketsData, MarketsParams, MarketsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/messages/messages.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 { Messages, MessagesData, MessagesPatch, MessagesQuery } from './messages.schema';
 export type { Messages, MessagesData, MessagesPatch, MessagesQuery };
 export interface MessagesParams extends MongoDBAdapterParams<MessagesQuery> {
 }
-export declare class MessagesService<ServiceParams extends Params = MessagesParams> extends FlexibleMongoDBService<Messages, MessagesData, MessagesParams, MessagesPatch> {
+export declare class MessagesService<ServiceParams extends Params = MessagesParams> extends MongoDBService<Messages, MessagesData, MessagesParams, MessagesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/models/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 { ModelsPodsEvents, ModelsPodsEventsData, ModelsPodsEventsPatch, ModelsPodsEventsQuery } from './events.schema';
 export type { ModelsPodsEvents, ModelsPodsEventsData, ModelsPodsEventsPatch, ModelsPodsEventsQuery };
 export interface ModelsPodsEventsParams extends MongoDBAdapterParams<ModelsPodsEventsQuery> {
 }
-export declare class ModelsPodsEventsService<ServiceParams extends Params = ModelsPodsEventsParams> extends FlexibleMongoDBService<ModelsPodsEvents, ModelsPodsEventsData, ModelsPodsEventsParams, ModelsPodsEventsPatch> {
+export declare class ModelsPodsEventsService<ServiceParams extends Params = ModelsPodsEventsParams> extends MongoDBService<ModelsPodsEvents, ModelsPodsEventsData, ModelsPodsEventsParams, ModelsPodsEventsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/models/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 { ModelsPods, ModelsPodsData, ModelsPodsPatch, ModelsPodsQuery } from './pods.schema';
 export type { ModelsPods, ModelsPodsData, ModelsPodsPatch, ModelsPodsQuery };
 export interface ModelsPodsParams extends MongoDBAdapterParams<ModelsPodsQuery> {
     user?: any;
 }
-export declare class ModelsPodsService<ServiceParams extends Params = ModelsPodsParams> extends FlexibleMongoDBService<ModelsPods, ModelsPodsData, ModelsPodsParams, ModelsPodsPatch> {
+export declare class ModelsPodsService<ServiceParams extends Params = ModelsPodsParams> extends MongoDBService<ModelsPods, ModelsPodsData, ModelsPodsParams, ModelsPodsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;