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

package/lib/src/services/autotune/trials/trials.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 { AutotuneTrial, AutotuneTrialData, AutotuneTrialPatch, AutotuneTrialQuery } from './trials.schema';
 export type { AutotuneTrial, AutotuneTrialData, AutotuneTrialPatch, AutotuneTrialQuery };
 export interface AutotuneTrialsParams extends MongoDBAdapterParams<AutotuneTrialQuery> {
     user?: any;
 }
-export declare class AutotuneTrialsService<ServiceParams extends Params = AutotuneTrialsParams> extends FlexibleMongoDBService<AutotuneTrial, AutotuneTrialData, AutotuneTrialsParams, AutotuneTrialPatch> {
+export declare class AutotuneTrialsService<ServiceParams extends Params = AutotuneTrialsParams> extends MongoDBService<AutotuneTrial, AutotuneTrialData, AutotuneTrialsParams, AutotuneTrialPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/autotune/usage/usage.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 { AutotuneUsage, AutotuneUsageData, AutotuneUsagePatch, AutotuneUsageQuery } from './usage.schema';
 export type { AutotuneUsage, AutotuneUsageData, AutotuneUsagePatch, AutotuneUsageQuery };
 export interface AutotuneUsageParams extends MongoDBAdapterParams<AutotuneUsageQuery> {
 }
-export declare class AutotuneUsageService<ServiceParams extends Params = AutotuneUsageParams> extends FlexibleMongoDBService<AutotuneUsage, AutotuneUsageData, AutotuneUsageParams, AutotuneUsagePatch> {
+export declare class AutotuneUsageService<ServiceParams extends Params = AutotuneUsageParams> extends MongoDBService<AutotuneUsage, AutotuneUsageData, AutotuneUsageParams, AutotuneUsagePatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/autotune/usage/usage.schema.d.ts

@@ -61,9 +61,9 @@ export declare const autotuneUsageExternalResolver: import("@feathersjs/schema")
     createdAt: any;
 }, HookContext<AutotuneUsageService<import("./usage.class").AutotuneUsageParams>>>;
 export declare const autotuneUsageDataSchema: import("@feathersjs/typebox").TObject<{
-    userId: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>, import("@feathersjs/typebox").TString<string>]>;
-    studyId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>, import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TNull]>>;
-    trialId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>, import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TNull]>>;
+    userId: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>;
+    studyId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>, import("@feathersjs/typebox").TNull]>>;
+    trialId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>, import("@feathersjs/typebox").TNull]>>;
     provider: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"batch">, import("@feathersjs/typebox").TLiteral<"docker">, import("@feathersjs/typebox").TLiteral<"ecs">, import("@feathersjs/typebox").TLiteral<"nomad">]>;
     state: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"reserved">, import("@feathersjs/typebox").TLiteral<"settled">, import("@feathersjs/typebox").TLiteral<"voided">]>;
     source: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"estimate">, import("@feathersjs/typebox").TLiteral<"aws-batch">, import("@feathersjs/typebox").TLiteral<"docker-events">, import("@feathersjs/typebox").TLiteral<"nomad-callback">, import("@feathersjs/typebox").TLiteral<"system">]>;

package/lib/src/services/blog/calendar/calendar.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 { BlogCalendar, BlogCalendarData, BlogCalendarPatch, BlogCalendarQuery } from './calendar.schema';
 export type { BlogCalendar, BlogCalendarData, BlogCalendarPatch, BlogCalendarQuery };
 export interface BlogCalendarParams extends MongoDBAdapterParams<BlogCalendarQuery> {
 }
-export declare class BlogCalendarService<ServiceParams extends Params = BlogCalendarParams> extends FlexibleMongoDBService<BlogCalendar, BlogCalendarData, BlogCalendarParams, BlogCalendarPatch> {
+export declare class BlogCalendarService<ServiceParams extends Params = BlogCalendarParams> extends MongoDBService<BlogCalendar, BlogCalendarData, BlogCalendarParams, BlogCalendarPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/blog/integrations/integrations.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 { BlogIntegrations, BlogIntegrationsData, BlogIntegrationsPatch, BlogIntegrationsQuery } from './integrations.schema';
 export type { BlogIntegrations, BlogIntegrationsData, BlogIntegrationsPatch, BlogIntegrationsQuery };
 export interface BlogIntegrationsParams extends MongoDBAdapterParams<BlogIntegrationsQuery> {
 }
-export declare class BlogIntegrationsService<ServiceParams extends Params = BlogIntegrationsParams> extends FlexibleMongoDBService<BlogIntegrations, BlogIntegrationsData, BlogIntegrationsParams, BlogIntegrationsPatch> {
+export declare class BlogIntegrationsService<ServiceParams extends Params = BlogIntegrationsParams> extends MongoDBService<BlogIntegrations, BlogIntegrationsData, BlogIntegrationsParams, BlogIntegrationsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/blog/posts/posts.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 { BlogPosts, BlogPostsData, BlogPostsPatch, BlogPostsQuery } from './posts.schema';
 export type { BlogPosts, BlogPostsData, BlogPostsPatch, BlogPostsQuery };
 export interface BlogPostsParams extends MongoDBAdapterParams<BlogPostsQuery> {
 }
-export declare class BlogPostsService<ServiceParams extends Params = BlogPostsParams> extends FlexibleMongoDBService<BlogPosts, BlogPostsData, BlogPostsParams, BlogPostsPatch> {
+export declare class BlogPostsService<ServiceParams extends Params = BlogPostsParams> extends MongoDBService<BlogPosts, BlogPostsData, BlogPostsParams, BlogPostsPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/blog/queries/queries.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 { BlogQueries, BlogQueriesData, BlogQueriesPatch, BlogQueriesQuery } from './queries.schema';
 export type { BlogQueries, BlogQueriesData, BlogQueriesPatch, BlogQueriesQuery };
 export interface BlogQueriesParams extends MongoDBAdapterParams<BlogQueriesQuery> {
 }
-export declare class BlogQueriesService<ServiceParams extends Params = BlogQueriesParams> extends FlexibleMongoDBService<BlogQueries, BlogQueriesData, BlogQueriesParams, BlogQueriesPatch> {
+export declare class BlogQueriesService<ServiceParams extends Params = BlogQueriesParams> extends MongoDBService<BlogQueries, BlogQueriesData, BlogQueriesParams, BlogQueriesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

package/lib/src/services/blog/sitemaps/pages/pages.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 { BlogSitemapsPages, BlogSitemapsPagesData, BlogSitemapsPagesPatch, BlogSitemapsPagesQuery } from './pages.schema';
 export type { BlogSitemapsPages, BlogSitemapsPagesData, BlogSitemapsPagesPatch, BlogSitemapsPagesQuery };
 export interface BlogSitemapsPagesParams extends MongoDBAdapterParams<BlogSitemapsPagesQuery> {
 }
-export declare class BlogSitemapsPagesService<ServiceParams extends Params = BlogSitemapsPagesParams> extends FlexibleMongoDBService<BlogSitemapsPages, BlogSitemapsPagesData, BlogSitemapsPagesParams, BlogSitemapsPagesPatch> {
+export declare class BlogSitemapsPagesService<ServiceParams extends Params = BlogSitemapsPagesParams> extends MongoDBService<BlogSitemapsPages, BlogSitemapsPagesData, BlogSitemapsPagesParams, BlogSitemapsPagesPatch> {
 }
 export declare const getOptions: (app: Application) => MongoDBAdapterOptions;

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/concerns/concerns.schema.d.ts

@@ -9,7 +9,7 @@ export declare const copilotConcernsSchema: import("@feathersjs/typebox").TObjec
     title: import("@feathersjs/typebox").TString<string>;
     description: import("@feathersjs/typebox").TString<string>;
     severity: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"info">, import("@feathersjs/typebox").TLiteral<"warning">, import("@feathersjs/typebox").TLiteral<"critical">]>;
-    traderId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TString<string>>;
+    traderId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>>;
     value: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TNumber>;
     status: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"active">, import("@feathersjs/typebox").TLiteral<"resolved">, import("@feathersjs/typebox").TLiteral<"acknowledged">]>;
     createdAt: import("@feathersjs/typebox").TString<"date-time">;
@@ -25,7 +25,7 @@ export declare const copilotConcernsResolver: import("@feathersjs/schema").Resol
     title: string;
     description: string;
     severity: "critical" | "info" | "warning";
-    traderId?: string | undefined;
+    traderId?: string | {} | undefined;
     value?: number | undefined;
     status: "acknowledged" | "active" | "resolved";
     createdAt: string;
@@ -39,7 +39,7 @@ export declare const copilotConcernsExternalResolver: import("@feathersjs/schema
     title: string;
     description: string;
     severity: "critical" | "info" | "warning";
-    traderId?: string | undefined;
+    traderId?: string | {} | undefined;
     value?: number | undefined;
     status: "acknowledged" | "active" | "resolved";
     createdAt: string;
@@ -53,7 +53,7 @@ export declare const copilotConcernsDataSchema: import("@feathersjs/typebox").TO
     title: import("@feathersjs/typebox").TString<string>;
     description: import("@feathersjs/typebox").TString<string>;
     severity: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"info">, import("@feathersjs/typebox").TLiteral<"warning">, import("@feathersjs/typebox").TLiteral<"critical">]>;
-    traderId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TString<string>>;
+    traderId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>>;
     value: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TNumber>;
     status: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"active">, import("@feathersjs/typebox").TLiteral<"resolved">, import("@feathersjs/typebox").TLiteral<"acknowledged">]>;
     createdAt: import("@feathersjs/typebox").TString<"date-time">;
@@ -69,7 +69,7 @@ export declare const copilotConcernsDataResolver: import("@feathersjs/schema").R
     title: string;
     description: string;
     severity: "critical" | "info" | "warning";
-    traderId?: string | undefined;
+    traderId?: string | {} | undefined;
     value?: number | undefined;
     status: "acknowledged" | "active" | "resolved";
     createdAt: string;
@@ -83,7 +83,7 @@ export declare const copilotConcernsPatchSchema: import("@feathersjs/typebox").T
     title: import("@feathersjs/typebox").TString<string>;
     description: import("@feathersjs/typebox").TString<string>;
     severity: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"info">, import("@feathersjs/typebox").TLiteral<"warning">, import("@feathersjs/typebox").TLiteral<"critical">]>;
-    traderId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TString<string>>;
+    traderId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>>;
     value: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TNumber>;
     status: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"active">, import("@feathersjs/typebox").TLiteral<"resolved">, import("@feathersjs/typebox").TLiteral<"acknowledged">]>;
     createdAt: import("@feathersjs/typebox").TString<"date-time">;
@@ -99,7 +99,7 @@ export declare const copilotConcernsPatchResolver: import("@feathersjs/schema").
     title: string;
     description: string;
     severity: "critical" | "info" | "warning";
-    traderId?: string | undefined;
+    traderId?: string | {} | undefined;
     value?: number | undefined;
     status: "acknowledged" | "active" | "resolved";
     createdAt: string;
@@ -113,7 +113,7 @@ export declare const copilotConcernsQueryProperties: import("@feathersjs/typebox
     title: import("@feathersjs/typebox").TString<string>;
     description: import("@feathersjs/typebox").TString<string>;
     severity: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"info">, import("@feathersjs/typebox").TLiteral<"warning">, import("@feathersjs/typebox").TLiteral<"critical">]>;
-    traderId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TString<string>>;
+    traderId: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>>;
     value: import("@feathersjs/typebox").TOptional<import("@feathersjs/typebox").TNumber>;
     status: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TLiteral<"active">, import("@feathersjs/typebox").TLiteral<"resolved">, import("@feathersjs/typebox").TLiteral<"acknowledged">]>;
     createdAt: import("@feathersjs/typebox").TString<"date-time">;

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;