adaptic-backend 1.0.3 → 1.0.5

package/generated/typegraphql-prisma/enhance.mjs

@@ -0,0 +1,1994 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyResolversEnhanceMap = applyResolversEnhanceMap;
+exports.applyArgsTypesEnhanceMap = applyArgsTypesEnhanceMap;
+exports.applyRelationResolversEnhanceMap = applyRelationResolversEnhanceMap;
+exports.applyModelsEnhanceMap = applyModelsEnhanceMap;
+exports.applyOutputTypesEnhanceMap = applyOutputTypesEnhanceMap;
+exports.applyInputTypesEnhanceMap = applyInputTypesEnhanceMap;
+const tslib = __importStar(require("tslib"));
+const crudResolvers = __importStar(require("./resolvers/crud/resolvers-crud.index"));
+const argsTypes = __importStar(require("./resolvers/crud/args.index"));
+const actionResolvers = __importStar(require("./resolvers/crud/resolvers-actions.index"));
+const relationResolvers = __importStar(require("./resolvers/relations/resolvers.index"));
+const models = __importStar(require("./models"));
+const outputTypes = __importStar(require("./resolvers/outputs"));
+const inputTypes = __importStar(require("./resolvers/inputs"));
+const crudResolversMap = {
+    Session: crudResolvers.SessionCrudResolver,
+    User: crudResolvers.UserCrudResolver,
+    Authenticator: crudResolvers.AuthenticatorCrudResolver,
+    Account: crudResolvers.AccountCrudResolver,
+    VerificationToken: crudResolvers.VerificationTokenCrudResolver,
+    Portfolio: crudResolvers.PortfolioCrudResolver,
+    PortfolioUser: crudResolvers.PortfolioUserCrudResolver,
+    EnvironmentVariable: crudResolvers.EnvironmentVariableCrudResolver,
+    Customer: crudResolvers.CustomerCrudResolver,
+    Asset: crudResolvers.AssetCrudResolver,
+    Holding: crudResolvers.HoldingCrudResolver,
+    Trade: crudResolvers.TradeCrudResolver,
+    TradeStep: crudResolvers.TradeStepCrudResolver,
+    Order: crudResolvers.OrderCrudResolver,
+    AIRecommendation: crudResolvers.AIRecommendationCrudResolver,
+    RiskAllocation: crudResolvers.RiskAllocationCrudResolver,
+    Alert: crudResolvers.AlertCrudResolver,
+    News: crudResolvers.NewsCrudResolver,
+    EconomicEvent: crudResolvers.EconomicEventCrudResolver,
+    PortfolioAllocation: crudResolvers.PortfolioAllocationCrudResolver,
+    PerformanceMetric: crudResolvers.PerformanceMetricCrudResolver
+};
+const actionResolversMap = {
+    Session: {
+        aggregateSession: actionResolvers.AggregateSessionResolver,
+        createManySession: actionResolvers.CreateManySessionResolver,
+        createOneSession: actionResolvers.CreateOneSessionResolver,
+        deleteManySession: actionResolvers.DeleteManySessionResolver,
+        deleteOneSession: actionResolvers.DeleteOneSessionResolver,
+        findFirstSession: actionResolvers.FindFirstSessionResolver,
+        findFirstSessionOrThrow: actionResolvers.FindFirstSessionOrThrowResolver,
+        sessions: actionResolvers.FindManySessionResolver,
+        session: actionResolvers.FindUniqueSessionResolver,
+        getSession: actionResolvers.FindUniqueSessionOrThrowResolver,
+        groupBySession: actionResolvers.GroupBySessionResolver,
+        updateManySession: actionResolvers.UpdateManySessionResolver,
+        updateOneSession: actionResolvers.UpdateOneSessionResolver,
+        upsertOneSession: actionResolvers.UpsertOneSessionResolver
+    },
+    User: {
+        aggregateUser: actionResolvers.AggregateUserResolver,
+        createManyUser: actionResolvers.CreateManyUserResolver,
+        createOneUser: actionResolvers.CreateOneUserResolver,
+        deleteManyUser: actionResolvers.DeleteManyUserResolver,
+        deleteOneUser: actionResolvers.DeleteOneUserResolver,
+        findFirstUser: actionResolvers.FindFirstUserResolver,
+        findFirstUserOrThrow: actionResolvers.FindFirstUserOrThrowResolver,
+        users: actionResolvers.FindManyUserResolver,
+        user: actionResolvers.FindUniqueUserResolver,
+        getUser: actionResolvers.FindUniqueUserOrThrowResolver,
+        groupByUser: actionResolvers.GroupByUserResolver,
+        updateManyUser: actionResolvers.UpdateManyUserResolver,
+        updateOneUser: actionResolvers.UpdateOneUserResolver,
+        upsertOneUser: actionResolvers.UpsertOneUserResolver
+    },
+    Authenticator: {
+        aggregateAuthenticator: actionResolvers.AggregateAuthenticatorResolver,
+        createManyAuthenticator: actionResolvers.CreateManyAuthenticatorResolver,
+        createOneAuthenticator: actionResolvers.CreateOneAuthenticatorResolver,
+        deleteManyAuthenticator: actionResolvers.DeleteManyAuthenticatorResolver,
+        deleteOneAuthenticator: actionResolvers.DeleteOneAuthenticatorResolver,
+        findFirstAuthenticator: actionResolvers.FindFirstAuthenticatorResolver,
+        findFirstAuthenticatorOrThrow: actionResolvers.FindFirstAuthenticatorOrThrowResolver,
+        authenticators: actionResolvers.FindManyAuthenticatorResolver,
+        authenticator: actionResolvers.FindUniqueAuthenticatorResolver,
+        getAuthenticator: actionResolvers.FindUniqueAuthenticatorOrThrowResolver,
+        groupByAuthenticator: actionResolvers.GroupByAuthenticatorResolver,
+        updateManyAuthenticator: actionResolvers.UpdateManyAuthenticatorResolver,
+        updateOneAuthenticator: actionResolvers.UpdateOneAuthenticatorResolver,
+        upsertOneAuthenticator: actionResolvers.UpsertOneAuthenticatorResolver
+    },
+    Account: {
+        aggregateAccount: actionResolvers.AggregateAccountResolver,
+        createManyAccount: actionResolvers.CreateManyAccountResolver,
+        createOneAccount: actionResolvers.CreateOneAccountResolver,
+        deleteManyAccount: actionResolvers.DeleteManyAccountResolver,
+        deleteOneAccount: actionResolvers.DeleteOneAccountResolver,
+        findFirstAccount: actionResolvers.FindFirstAccountResolver,
+        findFirstAccountOrThrow: actionResolvers.FindFirstAccountOrThrowResolver,
+        accounts: actionResolvers.FindManyAccountResolver,
+        account: actionResolvers.FindUniqueAccountResolver,
+        getAccount: actionResolvers.FindUniqueAccountOrThrowResolver,
+        groupByAccount: actionResolvers.GroupByAccountResolver,
+        updateManyAccount: actionResolvers.UpdateManyAccountResolver,
+        updateOneAccount: actionResolvers.UpdateOneAccountResolver,
+        upsertOneAccount: actionResolvers.UpsertOneAccountResolver
+    },
+    VerificationToken: {
+        aggregateVerificationToken: actionResolvers.AggregateVerificationTokenResolver,
+        createManyVerificationToken: actionResolvers.CreateManyVerificationTokenResolver,
+        createOneVerificationToken: actionResolvers.CreateOneVerificationTokenResolver,
+        deleteManyVerificationToken: actionResolvers.DeleteManyVerificationTokenResolver,
+        deleteOneVerificationToken: actionResolvers.DeleteOneVerificationTokenResolver,
+        findFirstVerificationToken: actionResolvers.FindFirstVerificationTokenResolver,
+        findFirstVerificationTokenOrThrow: actionResolvers.FindFirstVerificationTokenOrThrowResolver,
+        verificationTokens: actionResolvers.FindManyVerificationTokenResolver,
+        verificationToken: actionResolvers.FindUniqueVerificationTokenResolver,
+        getVerificationToken: actionResolvers.FindUniqueVerificationTokenOrThrowResolver,
+        groupByVerificationToken: actionResolvers.GroupByVerificationTokenResolver,
+        updateManyVerificationToken: actionResolvers.UpdateManyVerificationTokenResolver,
+        updateOneVerificationToken: actionResolvers.UpdateOneVerificationTokenResolver,
+        upsertOneVerificationToken: actionResolvers.UpsertOneVerificationTokenResolver
+    },
+    Portfolio: {
+        aggregatePortfolio: actionResolvers.AggregatePortfolioResolver,
+        createManyPortfolio: actionResolvers.CreateManyPortfolioResolver,
+        createOnePortfolio: actionResolvers.CreateOnePortfolioResolver,
+        deleteManyPortfolio: actionResolvers.DeleteManyPortfolioResolver,
+        deleteOnePortfolio: actionResolvers.DeleteOnePortfolioResolver,
+        findFirstPortfolio: actionResolvers.FindFirstPortfolioResolver,
+        findFirstPortfolioOrThrow: actionResolvers.FindFirstPortfolioOrThrowResolver,
+        portfolios: actionResolvers.FindManyPortfolioResolver,
+        portfolio: actionResolvers.FindUniquePortfolioResolver,
+        getPortfolio: actionResolvers.FindUniquePortfolioOrThrowResolver,
+        groupByPortfolio: actionResolvers.GroupByPortfolioResolver,
+        updateManyPortfolio: actionResolvers.UpdateManyPortfolioResolver,
+        updateOnePortfolio: actionResolvers.UpdateOnePortfolioResolver,
+        upsertOnePortfolio: actionResolvers.UpsertOnePortfolioResolver
+    },
+    PortfolioUser: {
+        aggregatePortfolioUser: actionResolvers.AggregatePortfolioUserResolver,
+        createManyPortfolioUser: actionResolvers.CreateManyPortfolioUserResolver,
+        createOnePortfolioUser: actionResolvers.CreateOnePortfolioUserResolver,
+        deleteManyPortfolioUser: actionResolvers.DeleteManyPortfolioUserResolver,
+        deleteOnePortfolioUser: actionResolvers.DeleteOnePortfolioUserResolver,
+        findFirstPortfolioUser: actionResolvers.FindFirstPortfolioUserResolver,
+        findFirstPortfolioUserOrThrow: actionResolvers.FindFirstPortfolioUserOrThrowResolver,
+        portfolioUsers: actionResolvers.FindManyPortfolioUserResolver,
+        portfolioUser: actionResolvers.FindUniquePortfolioUserResolver,
+        getPortfolioUser: actionResolvers.FindUniquePortfolioUserOrThrowResolver,
+        groupByPortfolioUser: actionResolvers.GroupByPortfolioUserResolver,
+        updateManyPortfolioUser: actionResolvers.UpdateManyPortfolioUserResolver,
+        updateOnePortfolioUser: actionResolvers.UpdateOnePortfolioUserResolver,
+        upsertOnePortfolioUser: actionResolvers.UpsertOnePortfolioUserResolver
+    },
+    EnvironmentVariable: {
+        aggregateEnvironmentVariable: actionResolvers.AggregateEnvironmentVariableResolver,
+        createManyEnvironmentVariable: actionResolvers.CreateManyEnvironmentVariableResolver,
+        createOneEnvironmentVariable: actionResolvers.CreateOneEnvironmentVariableResolver,
+        deleteManyEnvironmentVariable: actionResolvers.DeleteManyEnvironmentVariableResolver,
+        deleteOneEnvironmentVariable: actionResolvers.DeleteOneEnvironmentVariableResolver,
+        findFirstEnvironmentVariable: actionResolvers.FindFirstEnvironmentVariableResolver,
+        findFirstEnvironmentVariableOrThrow: actionResolvers.FindFirstEnvironmentVariableOrThrowResolver,
+        environmentVariables: actionResolvers.FindManyEnvironmentVariableResolver,
+        environmentVariable: actionResolvers.FindUniqueEnvironmentVariableResolver,
+        getEnvironmentVariable: actionResolvers.FindUniqueEnvironmentVariableOrThrowResolver,
+        groupByEnvironmentVariable: actionResolvers.GroupByEnvironmentVariableResolver,
+        updateManyEnvironmentVariable: actionResolvers.UpdateManyEnvironmentVariableResolver,
+        updateOneEnvironmentVariable: actionResolvers.UpdateOneEnvironmentVariableResolver,
+        upsertOneEnvironmentVariable: actionResolvers.UpsertOneEnvironmentVariableResolver
+    },
+    Customer: {
+        aggregateCustomer: actionResolvers.AggregateCustomerResolver,
+        createManyCustomer: actionResolvers.CreateManyCustomerResolver,
+        createOneCustomer: actionResolvers.CreateOneCustomerResolver,
+        deleteManyCustomer: actionResolvers.DeleteManyCustomerResolver,
+        deleteOneCustomer: actionResolvers.DeleteOneCustomerResolver,
+        findFirstCustomer: actionResolvers.FindFirstCustomerResolver,
+        findFirstCustomerOrThrow: actionResolvers.FindFirstCustomerOrThrowResolver,
+        customers: actionResolvers.FindManyCustomerResolver,
+        customer: actionResolvers.FindUniqueCustomerResolver,
+        getCustomer: actionResolvers.FindUniqueCustomerOrThrowResolver,
+        groupByCustomer: actionResolvers.GroupByCustomerResolver,
+        updateManyCustomer: actionResolvers.UpdateManyCustomerResolver,
+        updateOneCustomer: actionResolvers.UpdateOneCustomerResolver,
+        upsertOneCustomer: actionResolvers.UpsertOneCustomerResolver
+    },
+    Asset: {
+        aggregateAsset: actionResolvers.AggregateAssetResolver,
+        createManyAsset: actionResolvers.CreateManyAssetResolver,
+        createOneAsset: actionResolvers.CreateOneAssetResolver,
+        deleteManyAsset: actionResolvers.DeleteManyAssetResolver,
+        deleteOneAsset: actionResolvers.DeleteOneAssetResolver,
+        findFirstAsset: actionResolvers.FindFirstAssetResolver,
+        findFirstAssetOrThrow: actionResolvers.FindFirstAssetOrThrowResolver,
+        assets: actionResolvers.FindManyAssetResolver,
+        asset: actionResolvers.FindUniqueAssetResolver,
+        getAsset: actionResolvers.FindUniqueAssetOrThrowResolver,
+        groupByAsset: actionResolvers.GroupByAssetResolver,
+        updateManyAsset: actionResolvers.UpdateManyAssetResolver,
+        updateOneAsset: actionResolvers.UpdateOneAssetResolver,
+        upsertOneAsset: actionResolvers.UpsertOneAssetResolver
+    },
+    Holding: {
+        aggregateHolding: actionResolvers.AggregateHoldingResolver,
+        createManyHolding: actionResolvers.CreateManyHoldingResolver,
+        createOneHolding: actionResolvers.CreateOneHoldingResolver,
+        deleteManyHolding: actionResolvers.DeleteManyHoldingResolver,
+        deleteOneHolding: actionResolvers.DeleteOneHoldingResolver,
+        findFirstHolding: actionResolvers.FindFirstHoldingResolver,
+        findFirstHoldingOrThrow: actionResolvers.FindFirstHoldingOrThrowResolver,
+        holdings: actionResolvers.FindManyHoldingResolver,
+        holding: actionResolvers.FindUniqueHoldingResolver,
+        getHolding: actionResolvers.FindUniqueHoldingOrThrowResolver,
+        groupByHolding: actionResolvers.GroupByHoldingResolver,
+        updateManyHolding: actionResolvers.UpdateManyHoldingResolver,
+        updateOneHolding: actionResolvers.UpdateOneHoldingResolver,
+        upsertOneHolding: actionResolvers.UpsertOneHoldingResolver
+    },
+    Trade: {
+        aggregateTrade: actionResolvers.AggregateTradeResolver,
+        createManyTrade: actionResolvers.CreateManyTradeResolver,
+        createOneTrade: actionResolvers.CreateOneTradeResolver,
+        deleteManyTrade: actionResolvers.DeleteManyTradeResolver,
+        deleteOneTrade: actionResolvers.DeleteOneTradeResolver,
+        findFirstTrade: actionResolvers.FindFirstTradeResolver,
+        findFirstTradeOrThrow: actionResolvers.FindFirstTradeOrThrowResolver,
+        trades: actionResolvers.FindManyTradeResolver,
+        trade: actionResolvers.FindUniqueTradeResolver,
+        getTrade: actionResolvers.FindUniqueTradeOrThrowResolver,
+        groupByTrade: actionResolvers.GroupByTradeResolver,
+        updateManyTrade: actionResolvers.UpdateManyTradeResolver,
+        updateOneTrade: actionResolvers.UpdateOneTradeResolver,
+        upsertOneTrade: actionResolvers.UpsertOneTradeResolver
+    },
+    TradeStep: {
+        aggregateTradeStep: actionResolvers.AggregateTradeStepResolver,
+        createManyTradeStep: actionResolvers.CreateManyTradeStepResolver,
+        createOneTradeStep: actionResolvers.CreateOneTradeStepResolver,
+        deleteManyTradeStep: actionResolvers.DeleteManyTradeStepResolver,
+        deleteOneTradeStep: actionResolvers.DeleteOneTradeStepResolver,
+        findFirstTradeStep: actionResolvers.FindFirstTradeStepResolver,
+        findFirstTradeStepOrThrow: actionResolvers.FindFirstTradeStepOrThrowResolver,
+        tradeSteps: actionResolvers.FindManyTradeStepResolver,
+        tradeStep: actionResolvers.FindUniqueTradeStepResolver,
+        getTradeStep: actionResolvers.FindUniqueTradeStepOrThrowResolver,
+        groupByTradeStep: actionResolvers.GroupByTradeStepResolver,
+        updateManyTradeStep: actionResolvers.UpdateManyTradeStepResolver,
+        updateOneTradeStep: actionResolvers.UpdateOneTradeStepResolver,
+        upsertOneTradeStep: actionResolvers.UpsertOneTradeStepResolver
+    },
+    Order: {
+        aggregateOrder: actionResolvers.AggregateOrderResolver,
+        createManyOrder: actionResolvers.CreateManyOrderResolver,
+        createOneOrder: actionResolvers.CreateOneOrderResolver,
+        deleteManyOrder: actionResolvers.DeleteManyOrderResolver,
+        deleteOneOrder: actionResolvers.DeleteOneOrderResolver,
+        findFirstOrder: actionResolvers.FindFirstOrderResolver,
+        findFirstOrderOrThrow: actionResolvers.FindFirstOrderOrThrowResolver,
+        orders: actionResolvers.FindManyOrderResolver,
+        order: actionResolvers.FindUniqueOrderResolver,
+        getOrder: actionResolvers.FindUniqueOrderOrThrowResolver,
+        groupByOrder: actionResolvers.GroupByOrderResolver,
+        updateManyOrder: actionResolvers.UpdateManyOrderResolver,
+        updateOneOrder: actionResolvers.UpdateOneOrderResolver,
+        upsertOneOrder: actionResolvers.UpsertOneOrderResolver
+    },
+    AIRecommendation: {
+        aggregateAIRecommendation: actionResolvers.AggregateAIRecommendationResolver,
+        createManyAIRecommendation: actionResolvers.CreateManyAIRecommendationResolver,
+        createOneAIRecommendation: actionResolvers.CreateOneAIRecommendationResolver,
+        deleteManyAIRecommendation: actionResolvers.DeleteManyAIRecommendationResolver,
+        deleteOneAIRecommendation: actionResolvers.DeleteOneAIRecommendationResolver,
+        findFirstAIRecommendation: actionResolvers.FindFirstAIRecommendationResolver,
+        findFirstAIRecommendationOrThrow: actionResolvers.FindFirstAIRecommendationOrThrowResolver,
+        aIRecommendations: actionResolvers.FindManyAIRecommendationResolver,
+        aIRecommendation: actionResolvers.FindUniqueAIRecommendationResolver,
+        getAIRecommendation: actionResolvers.FindUniqueAIRecommendationOrThrowResolver,
+        groupByAIRecommendation: actionResolvers.GroupByAIRecommendationResolver,
+        updateManyAIRecommendation: actionResolvers.UpdateManyAIRecommendationResolver,
+        updateOneAIRecommendation: actionResolvers.UpdateOneAIRecommendationResolver,
+        upsertOneAIRecommendation: actionResolvers.UpsertOneAIRecommendationResolver
+    },
+    RiskAllocation: {
+        aggregateRiskAllocation: actionResolvers.AggregateRiskAllocationResolver,
+        createManyRiskAllocation: actionResolvers.CreateManyRiskAllocationResolver,
+        createOneRiskAllocation: actionResolvers.CreateOneRiskAllocationResolver,
+        deleteManyRiskAllocation: actionResolvers.DeleteManyRiskAllocationResolver,
+        deleteOneRiskAllocation: actionResolvers.DeleteOneRiskAllocationResolver,
+        findFirstRiskAllocation: actionResolvers.FindFirstRiskAllocationResolver,
+        findFirstRiskAllocationOrThrow: actionResolvers.FindFirstRiskAllocationOrThrowResolver,
+        riskAllocations: actionResolvers.FindManyRiskAllocationResolver,
+        riskAllocation: actionResolvers.FindUniqueRiskAllocationResolver,
+        getRiskAllocation: actionResolvers.FindUniqueRiskAllocationOrThrowResolver,
+        groupByRiskAllocation: actionResolvers.GroupByRiskAllocationResolver,
+        updateManyRiskAllocation: actionResolvers.UpdateManyRiskAllocationResolver,
+        updateOneRiskAllocation: actionResolvers.UpdateOneRiskAllocationResolver,
+        upsertOneRiskAllocation: actionResolvers.UpsertOneRiskAllocationResolver
+    },
+    Alert: {
+        aggregateAlert: actionResolvers.AggregateAlertResolver,
+        createManyAlert: actionResolvers.CreateManyAlertResolver,
+        createOneAlert: actionResolvers.CreateOneAlertResolver,
+        deleteManyAlert: actionResolvers.DeleteManyAlertResolver,
+        deleteOneAlert: actionResolvers.DeleteOneAlertResolver,
+        findFirstAlert: actionResolvers.FindFirstAlertResolver,
+        findFirstAlertOrThrow: actionResolvers.FindFirstAlertOrThrowResolver,
+        alerts: actionResolvers.FindManyAlertResolver,
+        alert: actionResolvers.FindUniqueAlertResolver,
+        getAlert: actionResolvers.FindUniqueAlertOrThrowResolver,
+        groupByAlert: actionResolvers.GroupByAlertResolver,
+        updateManyAlert: actionResolvers.UpdateManyAlertResolver,
+        updateOneAlert: actionResolvers.UpdateOneAlertResolver,
+        upsertOneAlert: actionResolvers.UpsertOneAlertResolver
+    },
+    News: {
+        aggregateNews: actionResolvers.AggregateNewsResolver,
+        createManyNews: actionResolvers.CreateManyNewsResolver,
+        createOneNews: actionResolvers.CreateOneNewsResolver,
+        deleteManyNews: actionResolvers.DeleteManyNewsResolver,
+        deleteOneNews: actionResolvers.DeleteOneNewsResolver,
+        findFirstNews: actionResolvers.FindFirstNewsResolver,
+        findFirstNewsOrThrow: actionResolvers.FindFirstNewsOrThrowResolver,
+        findManyNews: actionResolvers.FindManyNewsResolver,
+        findUniqueNews: actionResolvers.FindUniqueNewsResolver,
+        findUniqueNewsOrThrow: actionResolvers.FindUniqueNewsOrThrowResolver,
+        groupByNews: actionResolvers.GroupByNewsResolver,
+        updateManyNews: actionResolvers.UpdateManyNewsResolver,
+        updateOneNews: actionResolvers.UpdateOneNewsResolver,
+        upsertOneNews: actionResolvers.UpsertOneNewsResolver
+    },
+    EconomicEvent: {
+        aggregateEconomicEvent: actionResolvers.AggregateEconomicEventResolver,
+        createManyEconomicEvent: actionResolvers.CreateManyEconomicEventResolver,
+        createOneEconomicEvent: actionResolvers.CreateOneEconomicEventResolver,
+        deleteManyEconomicEvent: actionResolvers.DeleteManyEconomicEventResolver,
+        deleteOneEconomicEvent: actionResolvers.DeleteOneEconomicEventResolver,
+        findFirstEconomicEvent: actionResolvers.FindFirstEconomicEventResolver,
+        findFirstEconomicEventOrThrow: actionResolvers.FindFirstEconomicEventOrThrowResolver,
+        economicEvents: actionResolvers.FindManyEconomicEventResolver,
+        economicEvent: actionResolvers.FindUniqueEconomicEventResolver,
+        getEconomicEvent: actionResolvers.FindUniqueEconomicEventOrThrowResolver,
+        groupByEconomicEvent: actionResolvers.GroupByEconomicEventResolver,
+        updateManyEconomicEvent: actionResolvers.UpdateManyEconomicEventResolver,
+        updateOneEconomicEvent: actionResolvers.UpdateOneEconomicEventResolver,
+        upsertOneEconomicEvent: actionResolvers.UpsertOneEconomicEventResolver
+    },
+    PortfolioAllocation: {
+        aggregatePortfolioAllocation: actionResolvers.AggregatePortfolioAllocationResolver,
+        createManyPortfolioAllocation: actionResolvers.CreateManyPortfolioAllocationResolver,
+        createOnePortfolioAllocation: actionResolvers.CreateOnePortfolioAllocationResolver,
+        deleteManyPortfolioAllocation: actionResolvers.DeleteManyPortfolioAllocationResolver,
+        deleteOnePortfolioAllocation: actionResolvers.DeleteOnePortfolioAllocationResolver,
+        findFirstPortfolioAllocation: actionResolvers.FindFirstPortfolioAllocationResolver,
+        findFirstPortfolioAllocationOrThrow: actionResolvers.FindFirstPortfolioAllocationOrThrowResolver,
+        portfolioAllocations: actionResolvers.FindManyPortfolioAllocationResolver,
+        portfolioAllocation: actionResolvers.FindUniquePortfolioAllocationResolver,
+        getPortfolioAllocation: actionResolvers.FindUniquePortfolioAllocationOrThrowResolver,
+        groupByPortfolioAllocation: actionResolvers.GroupByPortfolioAllocationResolver,
+        updateManyPortfolioAllocation: actionResolvers.UpdateManyPortfolioAllocationResolver,
+        updateOnePortfolioAllocation: actionResolvers.UpdateOnePortfolioAllocationResolver,
+        upsertOnePortfolioAllocation: actionResolvers.UpsertOnePortfolioAllocationResolver
+    },
+    PerformanceMetric: {
+        aggregatePerformanceMetric: actionResolvers.AggregatePerformanceMetricResolver,
+        createManyPerformanceMetric: actionResolvers.CreateManyPerformanceMetricResolver,
+        createOnePerformanceMetric: actionResolvers.CreateOnePerformanceMetricResolver,
+        deleteManyPerformanceMetric: actionResolvers.DeleteManyPerformanceMetricResolver,
+        deleteOnePerformanceMetric: actionResolvers.DeleteOnePerformanceMetricResolver,
+        findFirstPerformanceMetric: actionResolvers.FindFirstPerformanceMetricResolver,
+        findFirstPerformanceMetricOrThrow: actionResolvers.FindFirstPerformanceMetricOrThrowResolver,
+        performanceMetrics: actionResolvers.FindManyPerformanceMetricResolver,
+        performanceMetric: actionResolvers.FindUniquePerformanceMetricResolver,
+        getPerformanceMetric: actionResolvers.FindUniquePerformanceMetricOrThrowResolver,
+        groupByPerformanceMetric: actionResolvers.GroupByPerformanceMetricResolver,
+        updateManyPerformanceMetric: actionResolvers.UpdateManyPerformanceMetricResolver,
+        updateOnePerformanceMetric: actionResolvers.UpdateOnePerformanceMetricResolver,
+        upsertOnePerformanceMetric: actionResolvers.UpsertOnePerformanceMetricResolver
+    }
+};
+const crudResolversInfo = {
+    Session: ["aggregateSession", "createManySession", "createOneSession", "deleteManySession", "deleteOneSession", "findFirstSession", "findFirstSessionOrThrow", "sessions", "session", "getSession", "groupBySession", "updateManySession", "updateOneSession", "upsertOneSession"],
+    User: ["aggregateUser", "createManyUser", "createOneUser", "deleteManyUser", "deleteOneUser", "findFirstUser", "findFirstUserOrThrow", "users", "user", "getUser", "groupByUser", "updateManyUser", "updateOneUser", "upsertOneUser"],
+    Authenticator: ["aggregateAuthenticator", "createManyAuthenticator", "createOneAuthenticator", "deleteManyAuthenticator", "deleteOneAuthenticator", "findFirstAuthenticator", "findFirstAuthenticatorOrThrow", "authenticators", "authenticator", "getAuthenticator", "groupByAuthenticator", "updateManyAuthenticator", "updateOneAuthenticator", "upsertOneAuthenticator"],
+    Account: ["aggregateAccount", "createManyAccount", "createOneAccount", "deleteManyAccount", "deleteOneAccount", "findFirstAccount", "findFirstAccountOrThrow", "accounts", "account", "getAccount", "groupByAccount", "updateManyAccount", "updateOneAccount", "upsertOneAccount"],
+    VerificationToken: ["aggregateVerificationToken", "createManyVerificationToken", "createOneVerificationToken", "deleteManyVerificationToken", "deleteOneVerificationToken", "findFirstVerificationToken", "findFirstVerificationTokenOrThrow", "verificationTokens", "verificationToken", "getVerificationToken", "groupByVerificationToken", "updateManyVerificationToken", "updateOneVerificationToken", "upsertOneVerificationToken"],
+    Portfolio: ["aggregatePortfolio", "createManyPortfolio", "createOnePortfolio", "deleteManyPortfolio", "deleteOnePortfolio", "findFirstPortfolio", "findFirstPortfolioOrThrow", "portfolios", "portfolio", "getPortfolio", "groupByPortfolio", "updateManyPortfolio", "updateOnePortfolio", "upsertOnePortfolio"],
+    PortfolioUser: ["aggregatePortfolioUser", "createManyPortfolioUser", "createOnePortfolioUser", "deleteManyPortfolioUser", "deleteOnePortfolioUser", "findFirstPortfolioUser", "findFirstPortfolioUserOrThrow", "portfolioUsers", "portfolioUser", "getPortfolioUser", "groupByPortfolioUser", "updateManyPortfolioUser", "updateOnePortfolioUser", "upsertOnePortfolioUser"],
+    EnvironmentVariable: ["aggregateEnvironmentVariable", "createManyEnvironmentVariable", "createOneEnvironmentVariable", "deleteManyEnvironmentVariable", "deleteOneEnvironmentVariable", "findFirstEnvironmentVariable", "findFirstEnvironmentVariableOrThrow", "environmentVariables", "environmentVariable", "getEnvironmentVariable", "groupByEnvironmentVariable", "updateManyEnvironmentVariable", "updateOneEnvironmentVariable", "upsertOneEnvironmentVariable"],
+    Customer: ["aggregateCustomer", "createManyCustomer", "createOneCustomer", "deleteManyCustomer", "deleteOneCustomer", "findFirstCustomer", "findFirstCustomerOrThrow", "customers", "customer", "getCustomer", "groupByCustomer", "updateManyCustomer", "updateOneCustomer", "upsertOneCustomer"],
+    Asset: ["aggregateAsset", "createManyAsset", "createOneAsset", "deleteManyAsset", "deleteOneAsset", "findFirstAsset", "findFirstAssetOrThrow", "assets", "asset", "getAsset", "groupByAsset", "updateManyAsset", "updateOneAsset", "upsertOneAsset"],
+    Holding: ["aggregateHolding", "createManyHolding", "createOneHolding", "deleteManyHolding", "deleteOneHolding", "findFirstHolding", "findFirstHoldingOrThrow", "holdings", "holding", "getHolding", "groupByHolding", "updateManyHolding", "updateOneHolding", "upsertOneHolding"],
+    Trade: ["aggregateTrade", "createManyTrade", "createOneTrade", "deleteManyTrade", "deleteOneTrade", "findFirstTrade", "findFirstTradeOrThrow", "trades", "trade", "getTrade", "groupByTrade", "updateManyTrade", "updateOneTrade", "upsertOneTrade"],
+    TradeStep: ["aggregateTradeStep", "createManyTradeStep", "createOneTradeStep", "deleteManyTradeStep", "deleteOneTradeStep", "findFirstTradeStep", "findFirstTradeStepOrThrow", "tradeSteps", "tradeStep", "getTradeStep", "groupByTradeStep", "updateManyTradeStep", "updateOneTradeStep", "upsertOneTradeStep"],
+    Order: ["aggregateOrder", "createManyOrder", "createOneOrder", "deleteManyOrder", "deleteOneOrder", "findFirstOrder", "findFirstOrderOrThrow", "orders", "order", "getOrder", "groupByOrder", "updateManyOrder", "updateOneOrder", "upsertOneOrder"],
+    AIRecommendation: ["aggregateAIRecommendation", "createManyAIRecommendation", "createOneAIRecommendation", "deleteManyAIRecommendation", "deleteOneAIRecommendation", "findFirstAIRecommendation", "findFirstAIRecommendationOrThrow", "aIRecommendations", "aIRecommendation", "getAIRecommendation", "groupByAIRecommendation", "updateManyAIRecommendation", "updateOneAIRecommendation", "upsertOneAIRecommendation"],
+    RiskAllocation: ["aggregateRiskAllocation", "createManyRiskAllocation", "createOneRiskAllocation", "deleteManyRiskAllocation", "deleteOneRiskAllocation", "findFirstRiskAllocation", "findFirstRiskAllocationOrThrow", "riskAllocations", "riskAllocation", "getRiskAllocation", "groupByRiskAllocation", "updateManyRiskAllocation", "updateOneRiskAllocation", "upsertOneRiskAllocation"],
+    Alert: ["aggregateAlert", "createManyAlert", "createOneAlert", "deleteManyAlert", "deleteOneAlert", "findFirstAlert", "findFirstAlertOrThrow", "alerts", "alert", "getAlert", "groupByAlert", "updateManyAlert", "updateOneAlert", "upsertOneAlert"],
+    News: ["aggregateNews", "createManyNews", "createOneNews", "deleteManyNews", "deleteOneNews", "findFirstNews", "findFirstNewsOrThrow", "findManyNews", "findUniqueNews", "findUniqueNewsOrThrow", "groupByNews", "updateManyNews", "updateOneNews", "upsertOneNews"],
+    EconomicEvent: ["aggregateEconomicEvent", "createManyEconomicEvent", "createOneEconomicEvent", "deleteManyEconomicEvent", "deleteOneEconomicEvent", "findFirstEconomicEvent", "findFirstEconomicEventOrThrow", "economicEvents", "economicEvent", "getEconomicEvent", "groupByEconomicEvent", "updateManyEconomicEvent", "updateOneEconomicEvent", "upsertOneEconomicEvent"],
+    PortfolioAllocation: ["aggregatePortfolioAllocation", "createManyPortfolioAllocation", "createOnePortfolioAllocation", "deleteManyPortfolioAllocation", "deleteOnePortfolioAllocation", "findFirstPortfolioAllocation", "findFirstPortfolioAllocationOrThrow", "portfolioAllocations", "portfolioAllocation", "getPortfolioAllocation", "groupByPortfolioAllocation", "updateManyPortfolioAllocation", "updateOnePortfolioAllocation", "upsertOnePortfolioAllocation"],
+    PerformanceMetric: ["aggregatePerformanceMetric", "createManyPerformanceMetric", "createOnePerformanceMetric", "deleteManyPerformanceMetric", "deleteOnePerformanceMetric", "findFirstPerformanceMetric", "findFirstPerformanceMetricOrThrow", "performanceMetrics", "performanceMetric", "getPerformanceMetric", "groupByPerformanceMetric", "updateManyPerformanceMetric", "updateOnePerformanceMetric", "upsertOnePerformanceMetric"]
+};
+const argsInfo = {
+    AggregateSessionArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManySessionArgs: ["data", "skipDuplicates"],
+    CreateOneSessionArgs: ["data"],
+    DeleteManySessionArgs: ["where"],
+    DeleteOneSessionArgs: ["where"],
+    FindFirstSessionArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstSessionOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManySessionArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueSessionArgs: ["where"],
+    FindUniqueSessionOrThrowArgs: ["where"],
+    GroupBySessionArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManySessionArgs: ["data", "where"],
+    UpdateOneSessionArgs: ["data", "where"],
+    UpsertOneSessionArgs: ["where", "create", "update"],
+    AggregateUserArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyUserArgs: ["data", "skipDuplicates"],
+    CreateOneUserArgs: ["data"],
+    DeleteManyUserArgs: ["where"],
+    DeleteOneUserArgs: ["where"],
+    FindFirstUserArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstUserOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyUserArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueUserArgs: ["where"],
+    FindUniqueUserOrThrowArgs: ["where"],
+    GroupByUserArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyUserArgs: ["data", "where"],
+    UpdateOneUserArgs: ["data", "where"],
+    UpsertOneUserArgs: ["where", "create", "update"],
+    AggregateAuthenticatorArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyAuthenticatorArgs: ["data", "skipDuplicates"],
+    CreateOneAuthenticatorArgs: ["data"],
+    DeleteManyAuthenticatorArgs: ["where"],
+    DeleteOneAuthenticatorArgs: ["where"],
+    FindFirstAuthenticatorArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstAuthenticatorOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyAuthenticatorArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueAuthenticatorArgs: ["where"],
+    FindUniqueAuthenticatorOrThrowArgs: ["where"],
+    GroupByAuthenticatorArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyAuthenticatorArgs: ["data", "where"],
+    UpdateOneAuthenticatorArgs: ["data", "where"],
+    UpsertOneAuthenticatorArgs: ["where", "create", "update"],
+    AggregateAccountArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyAccountArgs: ["data", "skipDuplicates"],
+    CreateOneAccountArgs: ["data"],
+    DeleteManyAccountArgs: ["where"],
+    DeleteOneAccountArgs: ["where"],
+    FindFirstAccountArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstAccountOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyAccountArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueAccountArgs: ["where"],
+    FindUniqueAccountOrThrowArgs: ["where"],
+    GroupByAccountArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyAccountArgs: ["data", "where"],
+    UpdateOneAccountArgs: ["data", "where"],
+    UpsertOneAccountArgs: ["where", "create", "update"],
+    AggregateVerificationTokenArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyVerificationTokenArgs: ["data", "skipDuplicates"],
+    CreateOneVerificationTokenArgs: ["data"],
+    DeleteManyVerificationTokenArgs: ["where"],
+    DeleteOneVerificationTokenArgs: ["where"],
+    FindFirstVerificationTokenArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstVerificationTokenOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyVerificationTokenArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueVerificationTokenArgs: ["where"],
+    FindUniqueVerificationTokenOrThrowArgs: ["where"],
+    GroupByVerificationTokenArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyVerificationTokenArgs: ["data", "where"],
+    UpdateOneVerificationTokenArgs: ["data", "where"],
+    UpsertOneVerificationTokenArgs: ["where", "create", "update"],
+    AggregatePortfolioArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyPortfolioArgs: ["data", "skipDuplicates"],
+    CreateOnePortfolioArgs: ["data"],
+    DeleteManyPortfolioArgs: ["where"],
+    DeleteOnePortfolioArgs: ["where"],
+    FindFirstPortfolioArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstPortfolioOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyPortfolioArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniquePortfolioArgs: ["where"],
+    FindUniquePortfolioOrThrowArgs: ["where"],
+    GroupByPortfolioArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyPortfolioArgs: ["data", "where"],
+    UpdateOnePortfolioArgs: ["data", "where"],
+    UpsertOnePortfolioArgs: ["where", "create", "update"],
+    AggregatePortfolioUserArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyPortfolioUserArgs: ["data", "skipDuplicates"],
+    CreateOnePortfolioUserArgs: ["data"],
+    DeleteManyPortfolioUserArgs: ["where"],
+    DeleteOnePortfolioUserArgs: ["where"],
+    FindFirstPortfolioUserArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstPortfolioUserOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyPortfolioUserArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniquePortfolioUserArgs: ["where"],
+    FindUniquePortfolioUserOrThrowArgs: ["where"],
+    GroupByPortfolioUserArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyPortfolioUserArgs: ["data", "where"],
+    UpdateOnePortfolioUserArgs: ["data", "where"],
+    UpsertOnePortfolioUserArgs: ["where", "create", "update"],
+    AggregateEnvironmentVariableArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyEnvironmentVariableArgs: ["data", "skipDuplicates"],
+    CreateOneEnvironmentVariableArgs: ["data"],
+    DeleteManyEnvironmentVariableArgs: ["where"],
+    DeleteOneEnvironmentVariableArgs: ["where"],
+    FindFirstEnvironmentVariableArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstEnvironmentVariableOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyEnvironmentVariableArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueEnvironmentVariableArgs: ["where"],
+    FindUniqueEnvironmentVariableOrThrowArgs: ["where"],
+    GroupByEnvironmentVariableArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyEnvironmentVariableArgs: ["data", "where"],
+    UpdateOneEnvironmentVariableArgs: ["data", "where"],
+    UpsertOneEnvironmentVariableArgs: ["where", "create", "update"],
+    AggregateCustomerArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyCustomerArgs: ["data", "skipDuplicates"],
+    CreateOneCustomerArgs: ["data"],
+    DeleteManyCustomerArgs: ["where"],
+    DeleteOneCustomerArgs: ["where"],
+    FindFirstCustomerArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstCustomerOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyCustomerArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueCustomerArgs: ["where"],
+    FindUniqueCustomerOrThrowArgs: ["where"],
+    GroupByCustomerArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyCustomerArgs: ["data", "where"],
+    UpdateOneCustomerArgs: ["data", "where"],
+    UpsertOneCustomerArgs: ["where", "create", "update"],
+    AggregateAssetArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyAssetArgs: ["data", "skipDuplicates"],
+    CreateOneAssetArgs: ["data"],
+    DeleteManyAssetArgs: ["where"],
+    DeleteOneAssetArgs: ["where"],
+    FindFirstAssetArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstAssetOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyAssetArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueAssetArgs: ["where"],
+    FindUniqueAssetOrThrowArgs: ["where"],
+    GroupByAssetArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyAssetArgs: ["data", "where"],
+    UpdateOneAssetArgs: ["data", "where"],
+    UpsertOneAssetArgs: ["where", "create", "update"],
+    AggregateHoldingArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyHoldingArgs: ["data", "skipDuplicates"],
+    CreateOneHoldingArgs: ["data"],
+    DeleteManyHoldingArgs: ["where"],
+    DeleteOneHoldingArgs: ["where"],
+    FindFirstHoldingArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstHoldingOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyHoldingArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueHoldingArgs: ["where"],
+    FindUniqueHoldingOrThrowArgs: ["where"],
+    GroupByHoldingArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyHoldingArgs: ["data", "where"],
+    UpdateOneHoldingArgs: ["data", "where"],
+    UpsertOneHoldingArgs: ["where", "create", "update"],
+    AggregateTradeArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyTradeArgs: ["data", "skipDuplicates"],
+    CreateOneTradeArgs: ["data"],
+    DeleteManyTradeArgs: ["where"],
+    DeleteOneTradeArgs: ["where"],
+    FindFirstTradeArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstTradeOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyTradeArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueTradeArgs: ["where"],
+    FindUniqueTradeOrThrowArgs: ["where"],
+    GroupByTradeArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyTradeArgs: ["data", "where"],
+    UpdateOneTradeArgs: ["data", "where"],
+    UpsertOneTradeArgs: ["where", "create", "update"],
+    AggregateTradeStepArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyTradeStepArgs: ["data", "skipDuplicates"],
+    CreateOneTradeStepArgs: ["data"],
+    DeleteManyTradeStepArgs: ["where"],
+    DeleteOneTradeStepArgs: ["where"],
+    FindFirstTradeStepArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstTradeStepOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyTradeStepArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueTradeStepArgs: ["where"],
+    FindUniqueTradeStepOrThrowArgs: ["where"],
+    GroupByTradeStepArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyTradeStepArgs: ["data", "where"],
+    UpdateOneTradeStepArgs: ["data", "where"],
+    UpsertOneTradeStepArgs: ["where", "create", "update"],
+    AggregateOrderArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyOrderArgs: ["data", "skipDuplicates"],
+    CreateOneOrderArgs: ["data"],
+    DeleteManyOrderArgs: ["where"],
+    DeleteOneOrderArgs: ["where"],
+    FindFirstOrderArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstOrderOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyOrderArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueOrderArgs: ["where"],
+    FindUniqueOrderOrThrowArgs: ["where"],
+    GroupByOrderArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyOrderArgs: ["data", "where"],
+    UpdateOneOrderArgs: ["data", "where"],
+    UpsertOneOrderArgs: ["where", "create", "update"],
+    AggregateAIRecommendationArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyAIRecommendationArgs: ["data", "skipDuplicates"],
+    CreateOneAIRecommendationArgs: ["data"],
+    DeleteManyAIRecommendationArgs: ["where"],
+    DeleteOneAIRecommendationArgs: ["where"],
+    FindFirstAIRecommendationArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstAIRecommendationOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyAIRecommendationArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueAIRecommendationArgs: ["where"],
+    FindUniqueAIRecommendationOrThrowArgs: ["where"],
+    GroupByAIRecommendationArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyAIRecommendationArgs: ["data", "where"],
+    UpdateOneAIRecommendationArgs: ["data", "where"],
+    UpsertOneAIRecommendationArgs: ["where", "create", "update"],
+    AggregateRiskAllocationArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyRiskAllocationArgs: ["data", "skipDuplicates"],
+    CreateOneRiskAllocationArgs: ["data"],
+    DeleteManyRiskAllocationArgs: ["where"],
+    DeleteOneRiskAllocationArgs: ["where"],
+    FindFirstRiskAllocationArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstRiskAllocationOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyRiskAllocationArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueRiskAllocationArgs: ["where"],
+    FindUniqueRiskAllocationOrThrowArgs: ["where"],
+    GroupByRiskAllocationArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyRiskAllocationArgs: ["data", "where"],
+    UpdateOneRiskAllocationArgs: ["data", "where"],
+    UpsertOneRiskAllocationArgs: ["where", "create", "update"],
+    AggregateAlertArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyAlertArgs: ["data", "skipDuplicates"],
+    CreateOneAlertArgs: ["data"],
+    DeleteManyAlertArgs: ["where"],
+    DeleteOneAlertArgs: ["where"],
+    FindFirstAlertArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstAlertOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyAlertArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueAlertArgs: ["where"],
+    FindUniqueAlertOrThrowArgs: ["where"],
+    GroupByAlertArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyAlertArgs: ["data", "where"],
+    UpdateOneAlertArgs: ["data", "where"],
+    UpsertOneAlertArgs: ["where", "create", "update"],
+    AggregateNewsArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyNewsArgs: ["data", "skipDuplicates"],
+    CreateOneNewsArgs: ["data"],
+    DeleteManyNewsArgs: ["where"],
+    DeleteOneNewsArgs: ["where"],
+    FindFirstNewsArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstNewsOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyNewsArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueNewsArgs: ["where"],
+    FindUniqueNewsOrThrowArgs: ["where"],
+    GroupByNewsArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyNewsArgs: ["data", "where"],
+    UpdateOneNewsArgs: ["data", "where"],
+    UpsertOneNewsArgs: ["where", "create", "update"],
+    AggregateEconomicEventArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyEconomicEventArgs: ["data", "skipDuplicates"],
+    CreateOneEconomicEventArgs: ["data"],
+    DeleteManyEconomicEventArgs: ["where"],
+    DeleteOneEconomicEventArgs: ["where"],
+    FindFirstEconomicEventArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstEconomicEventOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyEconomicEventArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniqueEconomicEventArgs: ["where"],
+    FindUniqueEconomicEventOrThrowArgs: ["where"],
+    GroupByEconomicEventArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyEconomicEventArgs: ["data", "where"],
+    UpdateOneEconomicEventArgs: ["data", "where"],
+    UpsertOneEconomicEventArgs: ["where", "create", "update"],
+    AggregatePortfolioAllocationArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyPortfolioAllocationArgs: ["data", "skipDuplicates"],
+    CreateOnePortfolioAllocationArgs: ["data"],
+    DeleteManyPortfolioAllocationArgs: ["where"],
+    DeleteOnePortfolioAllocationArgs: ["where"],
+    FindFirstPortfolioAllocationArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstPortfolioAllocationOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyPortfolioAllocationArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniquePortfolioAllocationArgs: ["where"],
+    FindUniquePortfolioAllocationOrThrowArgs: ["where"],
+    GroupByPortfolioAllocationArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyPortfolioAllocationArgs: ["data", "where"],
+    UpdateOnePortfolioAllocationArgs: ["data", "where"],
+    UpsertOnePortfolioAllocationArgs: ["where", "create", "update"],
+    AggregatePerformanceMetricArgs: ["where", "orderBy", "cursor", "take", "skip"],
+    CreateManyPerformanceMetricArgs: ["data", "skipDuplicates"],
+    CreateOnePerformanceMetricArgs: ["data"],
+    DeleteManyPerformanceMetricArgs: ["where"],
+    DeleteOnePerformanceMetricArgs: ["where"],
+    FindFirstPerformanceMetricArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindFirstPerformanceMetricOrThrowArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindManyPerformanceMetricArgs: ["where", "orderBy", "cursor", "take", "skip", "distinct"],
+    FindUniquePerformanceMetricArgs: ["where"],
+    FindUniquePerformanceMetricOrThrowArgs: ["where"],
+    GroupByPerformanceMetricArgs: ["where", "orderBy", "by", "having", "take", "skip"],
+    UpdateManyPerformanceMetricArgs: ["data", "where"],
+    UpdateOnePerformanceMetricArgs: ["data", "where"],
+    UpsertOnePerformanceMetricArgs: ["where", "create", "update"]
+};
+function applyResolversEnhanceMap(resolversEnhanceMap) {
+    const mutationOperationPrefixes = [
+        "createOne", "createMany", "deleteOne", "updateOne", "deleteMany", "updateMany", "upsertOne"
+    ];
+    for (const resolversEnhanceMapKey of Object.keys(resolversEnhanceMap)) {
+        const modelName = resolversEnhanceMapKey;
+        const crudTarget = crudResolversMap[modelName].prototype;
+        const resolverActionsConfig = resolversEnhanceMap[modelName];
+        const actionResolversConfig = actionResolversMap[modelName];
+        const allActionsDecorators = resolverActionsConfig._all;
+        const resolverActionNames = crudResolversInfo[modelName];
+        for (const resolverActionName of resolverActionNames) {
+            const maybeDecoratorsOrFn = resolverActionsConfig[resolverActionName];
+            const isWriteOperation = mutationOperationPrefixes.some(prefix => resolverActionName.startsWith(prefix));
+            const operationKindDecorators = isWriteOperation ? resolverActionsConfig._mutation : resolverActionsConfig._query;
+            const mainDecorators = [
+                ...allActionsDecorators !== null && allActionsDecorators !== void 0 ? allActionsDecorators : [],
+                ...operationKindDecorators !== null && operationKindDecorators !== void 0 ? operationKindDecorators : [],
+            ];
+            let decorators;
+            if (typeof maybeDecoratorsOrFn === "function") {
+                decorators = maybeDecoratorsOrFn(mainDecorators);
+            }
+            else {
+                decorators = [...mainDecorators, ...maybeDecoratorsOrFn !== null && maybeDecoratorsOrFn !== void 0 ? maybeDecoratorsOrFn : []];
+            }
+            const actionTarget = actionResolversConfig[resolverActionName].prototype;
+            tslib.__decorate(decorators, crudTarget, resolverActionName, null);
+            tslib.__decorate(decorators, actionTarget, resolverActionName, null);
+        }
+    }
+}
+function applyArgsTypesEnhanceMap(argsTypesEnhanceMap) {
+    for (const argsTypesEnhanceMapKey of Object.keys(argsTypesEnhanceMap)) {
+        const argsTypeName = argsTypesEnhanceMapKey;
+        const typeConfig = argsTypesEnhanceMap[argsTypeName];
+        const typeClass = argsTypes[argsTypeName];
+        const typeTarget = typeClass.prototype;
+        applyTypeClassEnhanceConfig(typeConfig, typeClass, typeTarget, argsInfo[argsTypeName]);
+    }
+}
+const relationResolversMap = {
+    Session: relationResolvers.SessionRelationsResolver,
+    User: relationResolvers.UserRelationsResolver,
+    Authenticator: relationResolvers.AuthenticatorRelationsResolver,
+    Account: relationResolvers.AccountRelationsResolver,
+    Portfolio: relationResolvers.PortfolioRelationsResolver,
+    PortfolioUser: relationResolvers.PortfolioUserRelationsResolver,
+    EnvironmentVariable: relationResolvers.EnvironmentVariableRelationsResolver,
+    Customer: relationResolvers.CustomerRelationsResolver,
+    Asset: relationResolvers.AssetRelationsResolver,
+    Holding: relationResolvers.HoldingRelationsResolver,
+    Trade: relationResolvers.TradeRelationsResolver,
+    TradeStep: relationResolvers.TradeStepRelationsResolver,
+    Order: relationResolvers.OrderRelationsResolver,
+    AIRecommendation: relationResolvers.AIRecommendationRelationsResolver,
+    RiskAllocation: relationResolvers.RiskAllocationRelationsResolver,
+    Alert: relationResolvers.AlertRelationsResolver,
+    News: relationResolvers.NewsRelationsResolver,
+    PortfolioAllocation: relationResolvers.PortfolioAllocationRelationsResolver,
+    PerformanceMetric: relationResolvers.PerformanceMetricRelationsResolver
+};
+const relationResolversInfo = {
+    Session: ["user"],
+    User: ["customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    Authenticator: ["user"],
+    Account: ["user"],
+    Portfolio: ["portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioUser: ["user", "portfolio"],
+    EnvironmentVariable: ["portfolio"],
+    Customer: ["users"],
+    Asset: ["holdings", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    Holding: ["user", "portfolio", "asset"],
+    Trade: ["user", "portfolio", "asset", "steps"],
+    TradeStep: ["trade"],
+    Order: ["user", "portfolio", "asset"],
+    AIRecommendation: ["user", "portfolio", "asset"],
+    RiskAllocation: ["user", "portfolio"],
+    Alert: ["user", "portfolio"],
+    News: ["asset"],
+    PortfolioAllocation: ["portfolio", "asset"],
+    PerformanceMetric: ["user", "portfolio"]
+};
+function applyRelationResolversEnhanceMap(relationResolversEnhanceMap) {
+    var _a;
+    for (const relationResolversEnhanceMapKey of Object.keys(relationResolversEnhanceMap)) {
+        const modelName = relationResolversEnhanceMapKey;
+        const relationResolverTarget = relationResolversMap[modelName].prototype;
+        const relationResolverActionsConfig = relationResolversEnhanceMap[modelName];
+        const allActionsDecorators = (_a = relationResolverActionsConfig._all) !== null && _a !== void 0 ? _a : [];
+        const relationResolverActionNames = relationResolversInfo[modelName];
+        for (const relationResolverActionName of relationResolverActionNames) {
+            const maybeDecoratorsOrFn = relationResolverActionsConfig[relationResolverActionName];
+            let decorators;
+            if (typeof maybeDecoratorsOrFn === "function") {
+                decorators = maybeDecoratorsOrFn(allActionsDecorators);
+            }
+            else {
+                decorators = [...allActionsDecorators, ...maybeDecoratorsOrFn !== null && maybeDecoratorsOrFn !== void 0 ? maybeDecoratorsOrFn : []];
+            }
+            tslib.__decorate(decorators, relationResolverTarget, relationResolverActionName, null);
+        }
+    }
+}
+function applyTypeClassEnhanceConfig(enhanceConfig, typeClass, typePrototype, typeFieldNames) {
+    var _a;
+    if (enhanceConfig.class) {
+        tslib.__decorate(enhanceConfig.class, typeClass);
+    }
+    if (enhanceConfig.fields) {
+        const allFieldsDecorators = (_a = enhanceConfig.fields._all) !== null && _a !== void 0 ? _a : [];
+        for (const typeFieldName of typeFieldNames) {
+            const maybeDecoratorsOrFn = enhanceConfig.fields[typeFieldName];
+            let decorators;
+            if (typeof maybeDecoratorsOrFn === "function") {
+                decorators = maybeDecoratorsOrFn(allFieldsDecorators);
+            }
+            else {
+                decorators = [...allFieldsDecorators, ...maybeDecoratorsOrFn !== null && maybeDecoratorsOrFn !== void 0 ? maybeDecoratorsOrFn : []];
+            }
+            tslib.__decorate(decorators, typePrototype, typeFieldName, void 0);
+        }
+    }
+}
+const modelsInfo = {
+    Session: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    User: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    Authenticator: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    Account: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    VerificationToken: ["id", "identifier", "token", "expires"],
+    Portfolio: ["id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioUser: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    EnvironmentVariable: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    Customer: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    Asset: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    Holding: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    Trade: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeStep: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    Order: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    AIRecommendation: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    RiskAllocation: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    Alert: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    News: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    EconomicEvent: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    PortfolioAllocation: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    PerformanceMetric: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"]
+};
+function applyModelsEnhanceMap(modelsEnhanceMap) {
+    for (const modelsEnhanceMapKey of Object.keys(modelsEnhanceMap)) {
+        const modelName = modelsEnhanceMapKey;
+        const modelConfig = modelsEnhanceMap[modelName];
+        const modelClass = models[modelName];
+        const modelTarget = modelClass.prototype;
+        applyTypeClassEnhanceConfig(modelConfig, modelClass, modelTarget, modelsInfo[modelName]);
+    }
+}
+const outputsInfo = {
+    AggregateSession: ["_count", "_min", "_max"],
+    SessionGroupBy: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AggregateUser: ["_count", "_avg", "_sum", "_min", "_max"],
+    UserGroupBy: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateAuthenticator: ["_count", "_avg", "_sum", "_min", "_max"],
+    AuthenticatorGroupBy: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateAccount: ["_count", "_avg", "_sum", "_min", "_max"],
+    AccountGroupBy: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateVerificationToken: ["_count", "_min", "_max"],
+    VerificationTokenGroupBy: ["id", "identifier", "token", "expires", "_count", "_min", "_max"],
+    AggregatePortfolio: ["_count", "_min", "_max"],
+    PortfolioGroupBy: ["id", "name", "description", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AggregatePortfolioUser: ["_count", "_min", "_max"],
+    PortfolioUserGroupBy: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AggregateEnvironmentVariable: ["_count", "_min", "_max"],
+    EnvironmentVariableGroupBy: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AggregateCustomer: ["_count", "_avg", "_sum", "_min", "_max"],
+    CustomerGroupBy: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateAsset: ["_count", "_min", "_max"],
+    AssetGroupBy: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AggregateHolding: ["_count", "_avg", "_sum", "_min", "_max"],
+    HoldingGroupBy: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateTrade: ["_count", "_avg", "_sum", "_min", "_max"],
+    TradeGroupBy: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateTradeStep: ["_count", "_avg", "_sum", "_min", "_max"],
+    TradeStepGroupBy: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateOrder: ["_count", "_avg", "_sum", "_min", "_max"],
+    OrderGroupBy: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateAIRecommendation: ["_count", "_avg", "_sum", "_min", "_max"],
+    AIRecommendationGroupBy: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateRiskAllocation: ["_count", "_avg", "_sum", "_min", "_max"],
+    RiskAllocationGroupBy: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregateAlert: ["_count", "_min", "_max"],
+    AlertGroupBy: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AggregateNews: ["_count", "_min", "_max"],
+    NewsGroupBy: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AggregateEconomicEvent: ["_count", "_min", "_max"],
+    EconomicEventGroupBy: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AggregatePortfolioAllocation: ["_count", "_avg", "_sum", "_min", "_max"],
+    PortfolioAllocationGroupBy: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt", "_count", "_avg", "_sum", "_min", "_max"],
+    AggregatePerformanceMetric: ["_count", "_min", "_max"],
+    PerformanceMetricGroupBy: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt", "_count", "_min", "_max"],
+    AffectedRowsOutput: ["count"],
+    SessionCountAggregate: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt", "_all"],
+    SessionMinAggregate: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    SessionMaxAggregate: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    UserCount: ["accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCountAggregate: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan", "_all"],
+    UserAvgAggregate: ["customerId"],
+    UserSumAggregate: ["customerId"],
+    UserMinAggregate: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    UserMaxAggregate: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    AuthenticatorCountAggregate: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt", "_all"],
+    AuthenticatorAvgAggregate: ["counter"],
+    AuthenticatorSumAggregate: ["counter"],
+    AuthenticatorMinAggregate: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AuthenticatorMaxAggregate: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AccountCountAggregate: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "_all"],
+    AccountAvgAggregate: ["expires_at"],
+    AccountSumAggregate: ["expires_at"],
+    AccountMinAggregate: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    AccountMaxAggregate: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    VerificationTokenCountAggregate: ["id", "identifier", "token", "expires", "_all"],
+    VerificationTokenMinAggregate: ["id", "identifier", "token", "expires"],
+    VerificationTokenMaxAggregate: ["id", "identifier", "token", "expires"],
+    PortfolioCount: ["portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCountAggregate: ["id", "name", "description", "createdAt", "updatedAt", "_all"],
+    PortfolioMinAggregate: ["id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioMaxAggregate: ["id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioUserCountAggregate: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt", "_all"],
+    PortfolioUserMinAggregate: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    PortfolioUserMaxAggregate: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    EnvironmentVariableCountAggregate: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt", "_all"],
+    EnvironmentVariableMinAggregate: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    EnvironmentVariableMaxAggregate: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    CustomerCount: ["users"],
+    CustomerCountAggregate: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt", "_all"],
+    CustomerAvgAggregate: ["id"],
+    CustomerSumAggregate: ["id"],
+    CustomerMinAggregate: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    CustomerMaxAggregate: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    AssetCount: ["holdings", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetCountAggregate: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "_all"],
+    AssetMinAggregate: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    AssetMaxAggregate: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    HoldingCountAggregate: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt", "_all"],
+    HoldingAvgAggregate: ["quantity", "averagePrice"],
+    HoldingSumAggregate: ["quantity", "averagePrice"],
+    HoldingMinAggregate: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    HoldingMaxAggregate: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    TradeCount: ["steps"],
+    TradeCountAggregate: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "_all"],
+    TradeAvgAggregate: ["quantity", "price", "total"],
+    TradeSumAggregate: ["quantity", "price", "total"],
+    TradeMinAggregate: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeMaxAggregate: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeStepCountAggregate: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "_all"],
+    TradeStepAvgAggregate: ["sequence", "hedgePrice", "buyPrice", "sellPrice", "qty", "stopLoss", "targetPrice", "fee"],
+    TradeStepSumAggregate: ["sequence", "hedgePrice", "buyPrice", "sellPrice", "qty", "stopLoss", "targetPrice", "fee"],
+    TradeStepMinAggregate: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    TradeStepMaxAggregate: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    OrderCountAggregate: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "_all"],
+    OrderAvgAggregate: ["quantity", "price"],
+    OrderSumAggregate: ["quantity", "price"],
+    OrderMinAggregate: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    OrderMaxAggregate: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    AIRecommendationCountAggregate: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt", "_all"],
+    AIRecommendationAvgAggregate: ["confidence"],
+    AIRecommendationSumAggregate: ["confidence"],
+    AIRecommendationMinAggregate: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    AIRecommendationMaxAggregate: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    RiskAllocationCountAggregate: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt", "_all"],
+    RiskAllocationAvgAggregate: ["allocation"],
+    RiskAllocationSumAggregate: ["allocation"],
+    RiskAllocationMinAggregate: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    RiskAllocationMaxAggregate: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    AlertCountAggregate: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt", "_all"],
+    AlertMinAggregate: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    AlertMaxAggregate: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    NewsCountAggregate: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "_all"],
+    NewsMinAggregate: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    NewsMaxAggregate: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    EconomicEventCountAggregate: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt", "_all"],
+    EconomicEventMinAggregate: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventMaxAggregate: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    PortfolioAllocationCountAggregate: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt", "_all"],
+    PortfolioAllocationAvgAggregate: ["allocation"],
+    PortfolioAllocationSumAggregate: ["allocation"],
+    PortfolioAllocationMinAggregate: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    PortfolioAllocationMaxAggregate: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    PerformanceMetricCountAggregate: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt", "_all"],
+    PerformanceMetricMinAggregate: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    PerformanceMetricMaxAggregate: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    CreateManySessionAndReturnOutputType: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt", "user"],
+    CreateManyUserAndReturnOutputType: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan", "customer"],
+    CreateManyAuthenticatorAndReturnOutputType: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt", "user"],
+    CreateManyAccountAndReturnOutputType: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "user"],
+    CreateManyVerificationTokenAndReturnOutputType: ["id", "identifier", "token", "expires"],
+    CreateManyPortfolioAndReturnOutputType: ["id", "name", "description", "createdAt", "updatedAt"],
+    CreateManyPortfolioUserAndReturnOutputType: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt", "user", "portfolio"],
+    CreateManyEnvironmentVariableAndReturnOutputType: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt", "portfolio"],
+    CreateManyCustomerAndReturnOutputType: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    CreateManyAssetAndReturnOutputType: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    CreateManyHoldingAndReturnOutputType: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    CreateManyTradeAndReturnOutputType: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "asset"],
+    CreateManyTradeStepAndReturnOutputType: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "trade"],
+    CreateManyOrderAndReturnOutputType: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    CreateManyAIRecommendationAndReturnOutputType: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    CreateManyRiskAllocationAndReturnOutputType: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt", "user", "portfolio"],
+    CreateManyAlertAndReturnOutputType: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt", "user", "portfolio"],
+    CreateManyNewsAndReturnOutputType: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "asset"],
+    CreateManyEconomicEventAndReturnOutputType: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    CreateManyPortfolioAllocationAndReturnOutputType: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt", "portfolio", "asset"],
+    CreateManyPerformanceMetricAndReturnOutputType: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt", "user", "portfolio"]
+};
+function applyOutputTypesEnhanceMap(outputTypesEnhanceMap) {
+    for (const outputTypeEnhanceMapKey of Object.keys(outputTypesEnhanceMap)) {
+        const outputTypeName = outputTypeEnhanceMapKey;
+        const typeConfig = outputTypesEnhanceMap[outputTypeName];
+        const typeClass = outputTypes[outputTypeName];
+        const typeTarget = typeClass.prototype;
+        applyTypeClassEnhanceConfig(typeConfig, typeClass, typeTarget, outputsInfo[outputTypeName]);
+    }
+}
+const inputsInfo = {
+    SessionWhereInput: ["AND", "OR", "NOT", "id", "sessionToken", "userId", "expires", "createdAt", "updatedAt", "user"],
+    SessionOrderByWithRelationInput: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt", "user"],
+    SessionWhereUniqueInput: ["id", "sessionToken", "AND", "OR", "NOT", "userId", "expires", "createdAt", "updatedAt", "user"],
+    SessionOrderByWithAggregationInput: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    SessionScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    UserWhereInput: ["AND", "OR", "NOT", "id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserOrderByWithRelationInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserWhereUniqueInput: ["id", "email", "AND", "OR", "NOT", "name", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserOrderByWithAggregationInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan", "_count", "_avg", "_max", "_min", "_sum"],
+    UserScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    AuthenticatorWhereInput: ["AND", "OR", "NOT", "id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt", "user"],
+    AuthenticatorOrderByWithRelationInput: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt", "user"],
+    AuthenticatorWhereUniqueInput: ["id", "credentialID", "AND", "OR", "NOT", "userId", "publicKey", "counter", "createdAt", "updatedAt", "user"],
+    AuthenticatorOrderByWithAggregationInput: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt", "_count", "_avg", "_max", "_min", "_sum"],
+    AuthenticatorScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AccountWhereInput: ["AND", "OR", "NOT", "id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "user"],
+    AccountOrderByWithRelationInput: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "user"],
+    AccountWhereUniqueInput: ["id", "provider_providerAccountId", "AND", "OR", "NOT", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "user"],
+    AccountOrderByWithAggregationInput: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "_count", "_avg", "_max", "_min", "_sum"],
+    AccountScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    VerificationTokenWhereInput: ["AND", "OR", "NOT", "id", "identifier", "token", "expires"],
+    VerificationTokenOrderByWithRelationInput: ["id", "identifier", "token", "expires"],
+    VerificationTokenWhereUniqueInput: ["id", "token", "identifier_token", "AND", "OR", "NOT", "identifier", "expires"],
+    VerificationTokenOrderByWithAggregationInput: ["id", "identifier", "token", "expires", "_count", "_max", "_min"],
+    VerificationTokenScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "identifier", "token", "expires"],
+    PortfolioWhereInput: ["AND", "OR", "NOT", "id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioOrderByWithRelationInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioWhereUniqueInput: ["id", "AND", "OR", "NOT", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioOrderByWithAggregationInput: ["id", "name", "description", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    PortfolioScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioUserWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "role", "createdAt", "updatedAt", "user", "portfolio"],
+    PortfolioUserOrderByWithRelationInput: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt", "user", "portfolio"],
+    PortfolioUserWhereUniqueInput: ["id", "userId_portfolioId", "AND", "OR", "NOT", "userId", "portfolioId", "role", "createdAt", "updatedAt", "user", "portfolio"],
+    PortfolioUserOrderByWithAggregationInput: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    PortfolioUserScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    EnvironmentVariableWhereInput: ["AND", "OR", "NOT", "id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt", "portfolio"],
+    EnvironmentVariableOrderByWithRelationInput: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt", "portfolio"],
+    EnvironmentVariableWhereUniqueInput: ["id", "portfolioId_key", "AND", "OR", "NOT", "key", "value", "description", "portfolioId", "createdAt", "updatedAt", "portfolio"],
+    EnvironmentVariableOrderByWithAggregationInput: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    EnvironmentVariableScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    CustomerWhereInput: ["AND", "OR", "NOT", "id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt", "users"],
+    CustomerOrderByWithRelationInput: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt", "users"],
+    CustomerWhereUniqueInput: ["id", "stripeCustomerId", "stripeSubscriptionId", "AND", "OR", "NOT", "authUserId", "name", "plan", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt", "users"],
+    CustomerOrderByWithAggregationInput: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt", "_count", "_avg", "_max", "_min", "_sum"],
+    CustomerScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    AssetWhereInput: ["AND", "OR", "NOT", "id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetOrderByWithRelationInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetWhereUniqueInput: ["id", "symbol", "AND", "OR", "NOT", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetOrderByWithAggregationInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    AssetScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    HoldingWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    HoldingOrderByWithRelationInput: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    HoldingWhereUniqueInput: ["id", "userId_portfolioId_assetId", "AND", "OR", "NOT", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    HoldingOrderByWithAggregationInput: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt", "_count", "_avg", "_max", "_min", "_sum"],
+    HoldingScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    TradeWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "asset", "steps"],
+    TradeOrderByWithRelationInput: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "asset", "steps"],
+    TradeWhereUniqueInput: ["id", "AND", "OR", "NOT", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "asset", "steps"],
+    TradeOrderByWithAggregationInput: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "_count", "_avg", "_max", "_min", "_sum"],
+    TradeScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeStepWhereInput: ["AND", "OR", "NOT", "id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "trade"],
+    TradeStepOrderByWithRelationInput: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "trade"],
+    TradeStepWhereUniqueInput: ["id", "AND", "OR", "NOT", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "trade"],
+    TradeStepOrderByWithAggregationInput: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "_count", "_avg", "_max", "_min", "_sum"],
+    TradeStepScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    OrderWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    OrderOrderByWithRelationInput: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    OrderWhereUniqueInput: ["id", "AND", "OR", "NOT", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    OrderOrderByWithAggregationInput: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "_count", "_avg", "_max", "_min", "_sum"],
+    OrderScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    AIRecommendationWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    AIRecommendationOrderByWithRelationInput: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    AIRecommendationWhereUniqueInput: ["id", "AND", "OR", "NOT", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    AIRecommendationOrderByWithAggregationInput: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt", "_count", "_avg", "_max", "_min", "_sum"],
+    AIRecommendationScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    RiskAllocationWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt", "user", "portfolio"],
+    RiskAllocationOrderByWithRelationInput: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt", "user", "portfolio"],
+    RiskAllocationWhereUniqueInput: ["id", "userId_portfolioId_assetType", "AND", "OR", "NOT", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt", "user", "portfolio"],
+    RiskAllocationOrderByWithAggregationInput: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt", "_count", "_avg", "_max", "_min", "_sum"],
+    RiskAllocationScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    AlertWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt", "user", "portfolio"],
+    AlertOrderByWithRelationInput: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt", "user", "portfolio"],
+    AlertWhereUniqueInput: ["id", "AND", "OR", "NOT", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt", "user", "portfolio"],
+    AlertOrderByWithAggregationInput: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    AlertScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    NewsWhereInput: ["AND", "OR", "NOT", "id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "asset"],
+    NewsOrderByWithRelationInput: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "asset"],
+    NewsWhereUniqueInput: ["id", "AND", "OR", "NOT", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "asset"],
+    NewsOrderByWithAggregationInput: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    NewsScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    EconomicEventWhereInput: ["AND", "OR", "NOT", "id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventOrderByWithRelationInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventWhereUniqueInput: ["id", "AND", "OR", "NOT", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventOrderByWithAggregationInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    EconomicEventScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    PortfolioAllocationWhereInput: ["AND", "OR", "NOT", "id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt", "portfolio", "asset"],
+    PortfolioAllocationOrderByWithRelationInput: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt", "portfolio", "asset"],
+    PortfolioAllocationWhereUniqueInput: ["id", "portfolioId_assetId", "AND", "OR", "NOT", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt", "portfolio", "asset"],
+    PortfolioAllocationOrderByWithAggregationInput: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt", "_count", "_avg", "_max", "_min", "_sum"],
+    PortfolioAllocationScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    PerformanceMetricWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt", "user", "portfolio"],
+    PerformanceMetricOrderByWithRelationInput: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt", "user", "portfolio"],
+    PerformanceMetricWhereUniqueInput: ["id", "AND", "OR", "NOT", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt", "user", "portfolio"],
+    PerformanceMetricOrderByWithAggregationInput: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt", "_count", "_max", "_min"],
+    PerformanceMetricScalarWhereWithAggregatesInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    SessionCreateInput: ["id", "sessionToken", "expires", "createdAt", "updatedAt", "user"],
+    SessionUpdateInput: ["id", "sessionToken", "expires", "createdAt", "updatedAt", "user"],
+    SessionCreateManyInput: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    SessionUpdateManyMutationInput: ["id", "sessionToken", "expires", "createdAt", "updatedAt"],
+    UserCreateInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserUpdateInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateManyInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    UserUpdateManyMutationInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan"],
+    AuthenticatorCreateInput: ["id", "credentialID", "publicKey", "counter", "createdAt", "updatedAt", "user"],
+    AuthenticatorUpdateInput: ["id", "credentialID", "publicKey", "counter", "createdAt", "updatedAt", "user"],
+    AuthenticatorCreateManyInput: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AuthenticatorUpdateManyMutationInput: ["id", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AccountCreateInput: ["id", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "user"],
+    AccountUpdateInput: ["id", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt", "user"],
+    AccountCreateManyInput: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    AccountUpdateManyMutationInput: ["id", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    VerificationTokenCreateInput: ["id", "identifier", "token", "expires"],
+    VerificationTokenUpdateInput: ["id", "identifier", "token", "expires"],
+    VerificationTokenCreateManyInput: ["id", "identifier", "token", "expires"],
+    VerificationTokenUpdateManyMutationInput: ["id", "identifier", "token", "expires"],
+    PortfolioCreateInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioUpdateInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateManyInput: ["id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioUpdateManyMutationInput: ["id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioUserCreateInput: ["id", "role", "createdAt", "updatedAt", "user", "portfolio"],
+    PortfolioUserUpdateInput: ["id", "role", "createdAt", "updatedAt", "user", "portfolio"],
+    PortfolioUserCreateManyInput: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    PortfolioUserUpdateManyMutationInput: ["id", "role", "createdAt", "updatedAt"],
+    EnvironmentVariableCreateInput: ["id", "key", "value", "description", "createdAt", "updatedAt", "portfolio"],
+    EnvironmentVariableUpdateInput: ["id", "key", "value", "description", "createdAt", "updatedAt", "portfolio"],
+    EnvironmentVariableCreateManyInput: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    EnvironmentVariableUpdateManyMutationInput: ["id", "key", "value", "description", "createdAt", "updatedAt"],
+    CustomerCreateInput: ["authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt", "users"],
+    CustomerUpdateInput: ["authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt", "users"],
+    CustomerCreateManyInput: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    CustomerUpdateManyMutationInput: ["authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    AssetCreateInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetUpdateInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetCreateManyInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    AssetUpdateManyMutationInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    HoldingCreateInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    HoldingUpdateInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    HoldingCreateManyInput: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    HoldingUpdateManyMutationInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    TradeCreateInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "asset", "steps"],
+    TradeUpdateInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "asset", "steps"],
+    TradeCreateManyInput: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeUpdateManyMutationInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeStepCreateInput: ["id", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "trade"],
+    TradeStepUpdateInput: ["id", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee", "trade"],
+    TradeStepCreateManyInput: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    TradeStepUpdateManyMutationInput: ["id", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    OrderCreateInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    OrderUpdateInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    OrderCreateManyInput: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    OrderUpdateManyMutationInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    AIRecommendationCreateInput: ["id", "action", "confidence", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    AIRecommendationUpdateInput: ["id", "action", "confidence", "createdAt", "updatedAt", "user", "portfolio", "asset"],
+    AIRecommendationCreateManyInput: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    AIRecommendationUpdateManyMutationInput: ["id", "action", "confidence", "createdAt", "updatedAt"],
+    RiskAllocationCreateInput: ["id", "assetType", "allocation", "createdAt", "updatedAt", "user", "portfolio"],
+    RiskAllocationUpdateInput: ["id", "assetType", "allocation", "createdAt", "updatedAt", "user", "portfolio"],
+    RiskAllocationCreateManyInput: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    RiskAllocationUpdateManyMutationInput: ["id", "assetType", "allocation", "createdAt", "updatedAt"],
+    AlertCreateInput: ["id", "message", "type", "isRead", "createdAt", "updatedAt", "user", "portfolio"],
+    AlertUpdateInput: ["id", "message", "type", "isRead", "createdAt", "updatedAt", "user", "portfolio"],
+    AlertCreateManyInput: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    AlertUpdateManyMutationInput: ["id", "message", "type", "isRead", "createdAt", "updatedAt"],
+    NewsCreateInput: ["id", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "asset"],
+    NewsUpdateInput: ["id", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt", "asset"],
+    NewsCreateManyInput: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    NewsUpdateManyMutationInput: ["id", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    EconomicEventCreateInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventUpdateInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventCreateManyInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventUpdateManyMutationInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    PortfolioAllocationCreateInput: ["id", "allocation", "createdAt", "updatedAt", "portfolio", "asset"],
+    PortfolioAllocationUpdateInput: ["id", "allocation", "createdAt", "updatedAt", "portfolio", "asset"],
+    PortfolioAllocationCreateManyInput: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    PortfolioAllocationUpdateManyMutationInput: ["id", "allocation", "createdAt", "updatedAt"],
+    PerformanceMetricCreateInput: ["id", "label", "value", "createdAt", "updatedAt", "user", "portfolio"],
+    PerformanceMetricUpdateInput: ["id", "label", "value", "createdAt", "updatedAt", "user", "portfolio"],
+    PerformanceMetricCreateManyInput: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    PerformanceMetricUpdateManyMutationInput: ["id", "label", "value", "createdAt", "updatedAt"],
+    StringFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "mode", "not"],
+    UuidFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "mode", "not"],
+    DateTimeFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    UserRelationFilter: ["is", "isNot"],
+    SessionCountOrderByAggregateInput: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    SessionMaxOrderByAggregateInput: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    SessionMinOrderByAggregateInput: ["id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    StringWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "mode", "not", "_count", "_min", "_max"],
+    UuidWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "mode", "not", "_count", "_min", "_max"],
+    DateTimeWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_min", "_max"],
+    StringNullableFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "mode", "not"],
+    DateTimeNullableFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    EnumUserRoleFilter: ["equals", "in", "notIn", "not"],
+    IntNullableFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    EnumSubscriptionPlanNullableFilter: ["equals", "in", "notIn", "not"],
+    CustomerNullableRelationFilter: ["is", "isNot"],
+    AccountListRelationFilter: ["every", "some", "none"],
+    SessionListRelationFilter: ["every", "some", "none"],
+    AuthenticatorListRelationFilter: ["every", "some", "none"],
+    HoldingListRelationFilter: ["every", "some", "none"],
+    TradeListRelationFilter: ["every", "some", "none"],
+    OrderListRelationFilter: ["every", "some", "none"],
+    AIRecommendationListRelationFilter: ["every", "some", "none"],
+    RiskAllocationListRelationFilter: ["every", "some", "none"],
+    AlertListRelationFilter: ["every", "some", "none"],
+    PortfolioUserListRelationFilter: ["every", "some", "none"],
+    PerformanceMetricListRelationFilter: ["every", "some", "none"],
+    SortOrderInput: ["sort", "nulls"],
+    AccountOrderByRelationAggregateInput: ["_count"],
+    SessionOrderByRelationAggregateInput: ["_count"],
+    AuthenticatorOrderByRelationAggregateInput: ["_count"],
+    HoldingOrderByRelationAggregateInput: ["_count"],
+    TradeOrderByRelationAggregateInput: ["_count"],
+    OrderOrderByRelationAggregateInput: ["_count"],
+    AIRecommendationOrderByRelationAggregateInput: ["_count"],
+    RiskAllocationOrderByRelationAggregateInput: ["_count"],
+    AlertOrderByRelationAggregateInput: ["_count"],
+    PortfolioUserOrderByRelationAggregateInput: ["_count"],
+    PerformanceMetricOrderByRelationAggregateInput: ["_count"],
+    UserCountOrderByAggregateInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    UserAvgOrderByAggregateInput: ["customerId"],
+    UserMaxOrderByAggregateInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    UserMinOrderByAggregateInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    UserSumOrderByAggregateInput: ["customerId"],
+    StringNullableWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "mode", "not", "_count", "_min", "_max"],
+    DateTimeNullableWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_min", "_max"],
+    EnumUserRoleWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    IntNullableWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_avg", "_sum", "_min", "_max"],
+    EnumSubscriptionPlanNullableWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    IntFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    AuthenticatorCountOrderByAggregateInput: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AuthenticatorAvgOrderByAggregateInput: ["counter"],
+    AuthenticatorMaxOrderByAggregateInput: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AuthenticatorMinOrderByAggregateInput: ["id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AuthenticatorSumOrderByAggregateInput: ["counter"],
+    IntWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_avg", "_sum", "_min", "_max"],
+    AccountProviderProviderAccountIdCompoundUniqueInput: ["provider", "providerAccountId"],
+    AccountCountOrderByAggregateInput: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    AccountAvgOrderByAggregateInput: ["expires_at"],
+    AccountMaxOrderByAggregateInput: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    AccountMinOrderByAggregateInput: ["id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    AccountSumOrderByAggregateInput: ["expires_at"],
+    VerificationTokenIdentifierTokenCompoundUniqueInput: ["identifier", "token"],
+    VerificationTokenCountOrderByAggregateInput: ["id", "identifier", "token", "expires"],
+    VerificationTokenMaxOrderByAggregateInput: ["id", "identifier", "token", "expires"],
+    VerificationTokenMinOrderByAggregateInput: ["id", "identifier", "token", "expires"],
+    PortfolioAllocationListRelationFilter: ["every", "some", "none"],
+    EnvironmentVariableListRelationFilter: ["every", "some", "none"],
+    PortfolioAllocationOrderByRelationAggregateInput: ["_count"],
+    EnvironmentVariableOrderByRelationAggregateInput: ["_count"],
+    PortfolioCountOrderByAggregateInput: ["id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioMaxOrderByAggregateInput: ["id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioMinOrderByAggregateInput: ["id", "name", "description", "createdAt", "updatedAt"],
+    PortfolioRelationFilter: ["is", "isNot"],
+    PortfolioUserUserIdPortfolioIdCompoundUniqueInput: ["userId", "portfolioId"],
+    PortfolioUserCountOrderByAggregateInput: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    PortfolioUserMaxOrderByAggregateInput: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    PortfolioUserMinOrderByAggregateInput: ["id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    EnvironmentVariablePortfolioIdKeyCompoundUniqueInput: ["portfolioId", "key"],
+    EnvironmentVariableCountOrderByAggregateInput: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    EnvironmentVariableMaxOrderByAggregateInput: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    EnvironmentVariableMinOrderByAggregateInput: ["id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    UserListRelationFilter: ["every", "some", "none"],
+    UserOrderByRelationAggregateInput: ["_count"],
+    CustomerCountOrderByAggregateInput: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    CustomerAvgOrderByAggregateInput: ["id"],
+    CustomerMaxOrderByAggregateInput: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    CustomerMinOrderByAggregateInput: ["id", "authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    CustomerSumOrderByAggregateInput: ["id"],
+    EnumAssetTypeFilter: ["equals", "in", "notIn", "not"],
+    NewsListRelationFilter: ["every", "some", "none"],
+    NewsOrderByRelationAggregateInput: ["_count"],
+    AssetCountOrderByAggregateInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    AssetMaxOrderByAggregateInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    AssetMinOrderByAggregateInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt"],
+    EnumAssetTypeWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    FloatFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    AssetRelationFilter: ["is", "isNot"],
+    HoldingUserIdPortfolioIdAssetIdCompoundUniqueInput: ["userId", "portfolioId", "assetId"],
+    HoldingCountOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    HoldingAvgOrderByAggregateInput: ["quantity", "averagePrice"],
+    HoldingMaxOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    HoldingMinOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    HoldingSumOrderByAggregateInput: ["quantity", "averagePrice"],
+    FloatWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_avg", "_sum", "_min", "_max"],
+    EnumTradeActionFilter: ["equals", "in", "notIn", "not"],
+    EnumTradeStatusFilter: ["equals", "in", "notIn", "not"],
+    TradeStepListRelationFilter: ["every", "some", "none"],
+    TradeStepOrderByRelationAggregateInput: ["_count"],
+    TradeCountOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeAvgOrderByAggregateInput: ["quantity", "price", "total"],
+    TradeMaxOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeMinOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    TradeSumOrderByAggregateInput: ["quantity", "price", "total"],
+    EnumTradeActionWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    EnumTradeStatusWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    EnumTradeStepActionFilter: ["equals", "in", "notIn", "not"],
+    FloatNullableFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    EnumTradeStepSideFilter: ["equals", "in", "notIn", "not"],
+    EnumOrderTypeFilter: ["equals", "in", "notIn", "not"],
+    EnumTradeStepStatusFilter: ["equals", "in", "notIn", "not"],
+    TradeRelationFilter: ["is", "isNot"],
+    TradeStepCountOrderByAggregateInput: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    TradeStepAvgOrderByAggregateInput: ["sequence", "hedgePrice", "buyPrice", "sellPrice", "qty", "stopLoss", "targetPrice", "fee"],
+    TradeStepMaxOrderByAggregateInput: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    TradeStepMinOrderByAggregateInput: ["id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    TradeStepSumOrderByAggregateInput: ["sequence", "hedgePrice", "buyPrice", "sellPrice", "qty", "stopLoss", "targetPrice", "fee"],
+    EnumTradeStepActionWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    FloatNullableWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_avg", "_sum", "_min", "_max"],
+    EnumTradeStepSideWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    EnumOrderTypeWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    EnumTradeStepStatusWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    EnumOrderStatusFilter: ["equals", "in", "notIn", "not"],
+    OrderCountOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    OrderAvgOrderByAggregateInput: ["quantity", "price"],
+    OrderMaxOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    OrderMinOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    OrderSumOrderByAggregateInput: ["quantity", "price"],
+    EnumOrderStatusWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    AIRecommendationCountOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    AIRecommendationAvgOrderByAggregateInput: ["confidence"],
+    AIRecommendationMaxOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    AIRecommendationMinOrderByAggregateInput: ["id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    AIRecommendationSumOrderByAggregateInput: ["confidence"],
+    RiskAllocationUserIdPortfolioIdAssetTypeCompoundUniqueInput: ["userId", "portfolioId", "assetType"],
+    RiskAllocationCountOrderByAggregateInput: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    RiskAllocationAvgOrderByAggregateInput: ["allocation"],
+    RiskAllocationMaxOrderByAggregateInput: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    RiskAllocationMinOrderByAggregateInput: ["id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    RiskAllocationSumOrderByAggregateInput: ["allocation"],
+    EnumAlertTypeFilter: ["equals", "in", "notIn", "not"],
+    BoolFilter: ["equals", "not"],
+    AlertCountOrderByAggregateInput: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    AlertMaxOrderByAggregateInput: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    AlertMinOrderByAggregateInput: ["id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    EnumAlertTypeWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    BoolWithAggregatesFilter: ["equals", "not", "_count", "_min", "_max"],
+    EnumNewsSentimentFilter: ["equals", "in", "notIn", "not"],
+    NewsCountOrderByAggregateInput: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    NewsMaxOrderByAggregateInput: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    NewsMinOrderByAggregateInput: ["id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    EnumNewsSentimentWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    EnumEventImportanceFilter: ["equals", "in", "notIn", "not"],
+    EconomicEventCountOrderByAggregateInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventMaxOrderByAggregateInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EconomicEventMinOrderByAggregateInput: ["id", "title", "description", "date", "importance", "createdAt", "updatedAt"],
+    EnumEventImportanceWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    PortfolioAllocationPortfolioIdAssetIdCompoundUniqueInput: ["portfolioId", "assetId"],
+    PortfolioAllocationCountOrderByAggregateInput: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    PortfolioAllocationAvgOrderByAggregateInput: ["allocation"],
+    PortfolioAllocationMaxOrderByAggregateInput: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    PortfolioAllocationMinOrderByAggregateInput: ["id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    PortfolioAllocationSumOrderByAggregateInput: ["allocation"],
+    PerformanceMetricCountOrderByAggregateInput: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    PerformanceMetricMaxOrderByAggregateInput: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    PerformanceMetricMinOrderByAggregateInput: ["id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    UserCreateNestedOneWithoutSessionsInput: ["create", "connectOrCreate", "connect"],
+    StringFieldUpdateOperationsInput: ["set"],
+    DateTimeFieldUpdateOperationsInput: ["set"],
+    UserUpdateOneRequiredWithoutSessionsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    CustomerCreateNestedOneWithoutUsersInput: ["create", "connectOrCreate", "connect"],
+    AccountCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    SessionCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    AuthenticatorCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    HoldingCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    TradeCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    OrderCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    AIRecommendationCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    RiskAllocationCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    AlertCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    PortfolioUserCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    PerformanceMetricCreateNestedManyWithoutUserInput: ["create", "connectOrCreate", "createMany", "connect"],
+    NullableStringFieldUpdateOperationsInput: ["set"],
+    NullableDateTimeFieldUpdateOperationsInput: ["set"],
+    EnumUserRoleFieldUpdateOperationsInput: ["set"],
+    NullableEnumSubscriptionPlanFieldUpdateOperationsInput: ["set"],
+    CustomerUpdateOneWithoutUsersNestedInput: ["create", "connectOrCreate", "upsert", "disconnect", "delete", "connect", "update"],
+    AccountUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    SessionUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    AuthenticatorUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    HoldingUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    TradeUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    OrderUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    AIRecommendationUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    RiskAllocationUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    AlertUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    PortfolioUserUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    PerformanceMetricUpdateManyWithoutUserNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    NullableIntFieldUpdateOperationsInput: ["set", "increment", "decrement", "multiply", "divide"],
+    UserCreateNestedOneWithoutAuthenticatorsInput: ["create", "connectOrCreate", "connect"],
+    IntFieldUpdateOperationsInput: ["set", "increment", "decrement", "multiply", "divide"],
+    UserUpdateOneRequiredWithoutAuthenticatorsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    UserCreateNestedOneWithoutAccountsInput: ["create", "connectOrCreate", "connect"],
+    UserUpdateOneRequiredWithoutAccountsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUserCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    HoldingCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    TradeCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    OrderCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    AIRecommendationCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    RiskAllocationCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    AlertCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    PerformanceMetricCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    PortfolioAllocationCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    EnvironmentVariableCreateNestedManyWithoutPortfolioInput: ["create", "connectOrCreate", "createMany", "connect"],
+    PortfolioUserUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    HoldingUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    TradeUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    OrderUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    AIRecommendationUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    RiskAllocationUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    AlertUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    PerformanceMetricUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    PortfolioAllocationUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    EnvironmentVariableUpdateManyWithoutPortfolioNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    UserCreateNestedOneWithoutPortfoliosInput: ["create", "connectOrCreate", "connect"],
+    PortfolioCreateNestedOneWithoutPortfolioUsersInput: ["create", "connectOrCreate", "connect"],
+    UserUpdateOneRequiredWithoutPortfoliosNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUpdateOneRequiredWithoutPortfolioUsersNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioCreateNestedOneWithoutEnvironmentVariablesInput: ["create", "connectOrCreate", "connect"],
+    PortfolioUpdateOneRequiredWithoutEnvironmentVariablesNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    UserCreateNestedManyWithoutCustomerInput: ["create", "connectOrCreate", "createMany", "connect"],
+    UserUpdateManyWithoutCustomerNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    HoldingCreateNestedManyWithoutAssetInput: ["create", "connectOrCreate", "createMany", "connect"],
+    TradeCreateNestedManyWithoutAssetInput: ["create", "connectOrCreate", "createMany", "connect"],
+    OrderCreateNestedManyWithoutAssetInput: ["create", "connectOrCreate", "createMany", "connect"],
+    AIRecommendationCreateNestedManyWithoutAssetInput: ["create", "connectOrCreate", "createMany", "connect"],
+    NewsCreateNestedManyWithoutAssetInput: ["create", "connectOrCreate", "createMany", "connect"],
+    PortfolioAllocationCreateNestedManyWithoutAssetInput: ["create", "connectOrCreate", "createMany", "connect"],
+    EnumAssetTypeFieldUpdateOperationsInput: ["set"],
+    HoldingUpdateManyWithoutAssetNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    TradeUpdateManyWithoutAssetNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    OrderUpdateManyWithoutAssetNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    AIRecommendationUpdateManyWithoutAssetNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    NewsUpdateManyWithoutAssetNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    PortfolioAllocationUpdateManyWithoutAssetNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    UserCreateNestedOneWithoutHoldingsInput: ["create", "connectOrCreate", "connect"],
+    PortfolioCreateNestedOneWithoutHoldingsInput: ["create", "connectOrCreate", "connect"],
+    AssetCreateNestedOneWithoutHoldingsInput: ["create", "connectOrCreate", "connect"],
+    FloatFieldUpdateOperationsInput: ["set", "increment", "decrement", "multiply", "divide"],
+    UserUpdateOneRequiredWithoutHoldingsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUpdateOneRequiredWithoutHoldingsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    AssetUpdateOneRequiredWithoutHoldingsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    UserCreateNestedOneWithoutTradesInput: ["create", "connectOrCreate", "connect"],
+    PortfolioCreateNestedOneWithoutTradesInput: ["create", "connectOrCreate", "connect"],
+    AssetCreateNestedOneWithoutTradesInput: ["create", "connectOrCreate", "connect"],
+    TradeStepCreateNestedManyWithoutTradeInput: ["create", "connectOrCreate", "createMany", "connect"],
+    EnumTradeActionFieldUpdateOperationsInput: ["set"],
+    EnumTradeStatusFieldUpdateOperationsInput: ["set"],
+    UserUpdateOneRequiredWithoutTradesNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUpdateOneRequiredWithoutTradesNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    AssetUpdateOneRequiredWithoutTradesNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    TradeStepUpdateManyWithoutTradeNestedInput: ["create", "connectOrCreate", "upsert", "createMany", "set", "disconnect", "delete", "connect", "update", "updateMany", "deleteMany"],
+    TradeCreateNestedOneWithoutStepsInput: ["create", "connectOrCreate", "connect"],
+    EnumTradeStepActionFieldUpdateOperationsInput: ["set"],
+    NullableFloatFieldUpdateOperationsInput: ["set", "increment", "decrement", "multiply", "divide"],
+    EnumTradeStepSideFieldUpdateOperationsInput: ["set"],
+    EnumOrderTypeFieldUpdateOperationsInput: ["set"],
+    EnumTradeStepStatusFieldUpdateOperationsInput: ["set"],
+    TradeUpdateOneRequiredWithoutStepsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    UserCreateNestedOneWithoutOrdersInput: ["create", "connectOrCreate", "connect"],
+    PortfolioCreateNestedOneWithoutOrdersInput: ["create", "connectOrCreate", "connect"],
+    AssetCreateNestedOneWithoutOrdersInput: ["create", "connectOrCreate", "connect"],
+    EnumOrderStatusFieldUpdateOperationsInput: ["set"],
+    UserUpdateOneRequiredWithoutOrdersNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUpdateOneRequiredWithoutOrdersNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    AssetUpdateOneRequiredWithoutOrdersNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    UserCreateNestedOneWithoutAiRecommendationsInput: ["create", "connectOrCreate", "connect"],
+    PortfolioCreateNestedOneWithoutAiRecommendationsInput: ["create", "connectOrCreate", "connect"],
+    AssetCreateNestedOneWithoutAiRecommendationsInput: ["create", "connectOrCreate", "connect"],
+    UserUpdateOneRequiredWithoutAiRecommendationsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUpdateOneRequiredWithoutAiRecommendationsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    AssetUpdateOneRequiredWithoutAiRecommendationsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    UserCreateNestedOneWithoutRiskAllocationsInput: ["create", "connectOrCreate", "connect"],
+    PortfolioCreateNestedOneWithoutRiskAllocationsInput: ["create", "connectOrCreate", "connect"],
+    UserUpdateOneRequiredWithoutRiskAllocationsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUpdateOneRequiredWithoutRiskAllocationsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    UserCreateNestedOneWithoutAlertsInput: ["create", "connectOrCreate", "connect"],
+    PortfolioCreateNestedOneWithoutAlertsInput: ["create", "connectOrCreate", "connect"],
+    EnumAlertTypeFieldUpdateOperationsInput: ["set"],
+    BoolFieldUpdateOperationsInput: ["set"],
+    UserUpdateOneRequiredWithoutAlertsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUpdateOneRequiredWithoutAlertsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    AssetCreateNestedOneWithoutNewsInput: ["create", "connectOrCreate", "connect"],
+    EnumNewsSentimentFieldUpdateOperationsInput: ["set"],
+    AssetUpdateOneRequiredWithoutNewsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    EnumEventImportanceFieldUpdateOperationsInput: ["set"],
+    PortfolioCreateNestedOneWithoutPortfolioAllocationsInput: ["create", "connectOrCreate", "connect"],
+    AssetCreateNestedOneWithoutPortfolioAllocationInput: ["create", "connectOrCreate", "connect"],
+    PortfolioUpdateOneRequiredWithoutPortfolioAllocationsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    AssetUpdateOneRequiredWithoutPortfolioAllocationNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    UserCreateNestedOneWithoutPerformanceMetricsInput: ["create", "connectOrCreate", "connect"],
+    PortfolioCreateNestedOneWithoutPerformanceMetricsInput: ["create", "connectOrCreate", "connect"],
+    UserUpdateOneRequiredWithoutPerformanceMetricsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    PortfolioUpdateOneRequiredWithoutPerformanceMetricsNestedInput: ["create", "connectOrCreate", "upsert", "connect", "update"],
+    NestedStringFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "not"],
+    NestedUuidFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    NestedDateTimeFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    NestedStringWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "not", "_count", "_min", "_max"],
+    NestedIntFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    NestedUuidWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_min", "_max"],
+    NestedDateTimeWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_min", "_max"],
+    NestedStringNullableFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "not"],
+    NestedDateTimeNullableFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    NestedEnumUserRoleFilter: ["equals", "in", "notIn", "not"],
+    NestedIntNullableFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    NestedEnumSubscriptionPlanNullableFilter: ["equals", "in", "notIn", "not"],
+    NestedStringNullableWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "not", "_count", "_min", "_max"],
+    NestedDateTimeNullableWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_min", "_max"],
+    NestedEnumUserRoleWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedIntNullableWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_avg", "_sum", "_min", "_max"],
+    NestedFloatNullableFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    NestedEnumSubscriptionPlanNullableWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedIntWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_avg", "_sum", "_min", "_max"],
+    NestedFloatFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not"],
+    NestedEnumAssetTypeFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumAssetTypeWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedFloatWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_avg", "_sum", "_min", "_max"],
+    NestedEnumTradeActionFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumTradeStatusFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumTradeActionWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedEnumTradeStatusWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedEnumTradeStepActionFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumTradeStepSideFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumOrderTypeFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumTradeStepStatusFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumTradeStepActionWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedFloatNullableWithAggregatesFilter: ["equals", "in", "notIn", "lt", "lte", "gt", "gte", "not", "_count", "_avg", "_sum", "_min", "_max"],
+    NestedEnumTradeStepSideWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedEnumOrderTypeWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedEnumTradeStepStatusWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedEnumOrderStatusFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumOrderStatusWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedEnumAlertTypeFilter: ["equals", "in", "notIn", "not"],
+    NestedBoolFilter: ["equals", "not"],
+    NestedEnumAlertTypeWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedBoolWithAggregatesFilter: ["equals", "not", "_count", "_min", "_max"],
+    NestedEnumNewsSentimentFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumNewsSentimentWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    NestedEnumEventImportanceFilter: ["equals", "in", "notIn", "not"],
+    NestedEnumEventImportanceWithAggregatesFilter: ["equals", "in", "notIn", "not", "_count", "_min", "_max"],
+    UserCreateWithoutSessionsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutSessionsInput: ["where", "create"],
+    UserUpsertWithoutSessionsInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutSessionsInput: ["where", "data"],
+    UserUpdateWithoutSessionsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    CustomerCreateWithoutUsersInput: ["authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    CustomerCreateOrConnectWithoutUsersInput: ["where", "create"],
+    AccountCreateWithoutUserInput: ["id", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    AccountCreateOrConnectWithoutUserInput: ["where", "create"],
+    AccountCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    SessionCreateWithoutUserInput: ["id", "sessionToken", "expires", "createdAt", "updatedAt"],
+    SessionCreateOrConnectWithoutUserInput: ["where", "create"],
+    SessionCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    AuthenticatorCreateWithoutUserInput: ["id", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    AuthenticatorCreateOrConnectWithoutUserInput: ["where", "create"],
+    AuthenticatorCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    HoldingCreateWithoutUserInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt", "portfolio", "asset"],
+    HoldingCreateOrConnectWithoutUserInput: ["where", "create"],
+    HoldingCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    TradeCreateWithoutUserInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "portfolio", "asset", "steps"],
+    TradeCreateOrConnectWithoutUserInput: ["where", "create"],
+    TradeCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    OrderCreateWithoutUserInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "portfolio", "asset"],
+    OrderCreateOrConnectWithoutUserInput: ["where", "create"],
+    OrderCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    AIRecommendationCreateWithoutUserInput: ["id", "action", "confidence", "createdAt", "updatedAt", "portfolio", "asset"],
+    AIRecommendationCreateOrConnectWithoutUserInput: ["where", "create"],
+    AIRecommendationCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    RiskAllocationCreateWithoutUserInput: ["id", "assetType", "allocation", "createdAt", "updatedAt", "portfolio"],
+    RiskAllocationCreateOrConnectWithoutUserInput: ["where", "create"],
+    RiskAllocationCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    AlertCreateWithoutUserInput: ["id", "message", "type", "isRead", "createdAt", "updatedAt", "portfolio"],
+    AlertCreateOrConnectWithoutUserInput: ["where", "create"],
+    AlertCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    PortfolioUserCreateWithoutUserInput: ["id", "role", "createdAt", "updatedAt", "portfolio"],
+    PortfolioUserCreateOrConnectWithoutUserInput: ["where", "create"],
+    PortfolioUserCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    PerformanceMetricCreateWithoutUserInput: ["id", "label", "value", "createdAt", "updatedAt", "portfolio"],
+    PerformanceMetricCreateOrConnectWithoutUserInput: ["where", "create"],
+    PerformanceMetricCreateManyUserInputEnvelope: ["data", "skipDuplicates"],
+    CustomerUpsertWithoutUsersInput: ["update", "create", "where"],
+    CustomerUpdateToOneWithWhereWithoutUsersInput: ["where", "data"],
+    CustomerUpdateWithoutUsersInput: ["authUserId", "name", "plan", "stripeCustomerId", "stripeSubscriptionId", "stripePriceId", "stripeCurrentPeriodEnd", "createdAt", "updatedAt"],
+    AccountUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    AccountUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    AccountUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    AccountScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    SessionUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    SessionUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    SessionUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    SessionScalarWhereInput: ["AND", "OR", "NOT", "id", "sessionToken", "userId", "expires", "createdAt", "updatedAt"],
+    AuthenticatorUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    AuthenticatorUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    AuthenticatorUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    AuthenticatorScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    HoldingUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    HoldingUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    HoldingUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    HoldingScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    TradeUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    TradeUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    TradeUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    TradeScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    OrderUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    OrderUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    OrderUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    OrderScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    AIRecommendationUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    AIRecommendationUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    AIRecommendationUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    AIRecommendationScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    RiskAllocationUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    RiskAllocationUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    RiskAllocationUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    RiskAllocationScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    AlertUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    AlertUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    AlertUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    AlertScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    PortfolioUserUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    PortfolioUserUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    PortfolioUserUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    PortfolioUserScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "role", "createdAt", "updatedAt"],
+    PerformanceMetricUpsertWithWhereUniqueWithoutUserInput: ["where", "update", "create"],
+    PerformanceMetricUpdateWithWhereUniqueWithoutUserInput: ["where", "data"],
+    PerformanceMetricUpdateManyWithWhereWithoutUserInput: ["where", "data"],
+    PerformanceMetricScalarWhereInput: ["AND", "OR", "NOT", "id", "userId", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    UserCreateWithoutAuthenticatorsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutAuthenticatorsInput: ["where", "create"],
+    UserUpsertWithoutAuthenticatorsInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutAuthenticatorsInput: ["where", "data"],
+    UserUpdateWithoutAuthenticatorsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateWithoutAccountsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutAccountsInput: ["where", "create"],
+    UserUpsertWithoutAccountsInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutAccountsInput: ["where", "data"],
+    UserUpdateWithoutAccountsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    PortfolioUserCreateWithoutPortfolioInput: ["id", "role", "createdAt", "updatedAt", "user"],
+    PortfolioUserCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    PortfolioUserCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    HoldingCreateWithoutPortfolioInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "asset"],
+    HoldingCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    HoldingCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    TradeCreateWithoutPortfolioInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "asset", "steps"],
+    TradeCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    TradeCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    OrderCreateWithoutPortfolioInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "asset"],
+    OrderCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    OrderCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    AIRecommendationCreateWithoutPortfolioInput: ["id", "action", "confidence", "createdAt", "updatedAt", "user", "asset"],
+    AIRecommendationCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    AIRecommendationCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    RiskAllocationCreateWithoutPortfolioInput: ["id", "assetType", "allocation", "createdAt", "updatedAt", "user"],
+    RiskAllocationCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    RiskAllocationCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    AlertCreateWithoutPortfolioInput: ["id", "message", "type", "isRead", "createdAt", "updatedAt", "user"],
+    AlertCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    AlertCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    PerformanceMetricCreateWithoutPortfolioInput: ["id", "label", "value", "createdAt", "updatedAt", "user"],
+    PerformanceMetricCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    PerformanceMetricCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    PortfolioAllocationCreateWithoutPortfolioInput: ["id", "allocation", "createdAt", "updatedAt", "asset"],
+    PortfolioAllocationCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    PortfolioAllocationCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    EnvironmentVariableCreateWithoutPortfolioInput: ["id", "key", "value", "description", "createdAt", "updatedAt"],
+    EnvironmentVariableCreateOrConnectWithoutPortfolioInput: ["where", "create"],
+    EnvironmentVariableCreateManyPortfolioInputEnvelope: ["data", "skipDuplicates"],
+    PortfolioUserUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    PortfolioUserUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    PortfolioUserUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    HoldingUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    HoldingUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    HoldingUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    TradeUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    TradeUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    TradeUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    OrderUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    OrderUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    OrderUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    AIRecommendationUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    AIRecommendationUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    AIRecommendationUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    RiskAllocationUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    RiskAllocationUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    RiskAllocationUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    AlertUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    AlertUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    AlertUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    PerformanceMetricUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    PerformanceMetricUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    PerformanceMetricUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    PortfolioAllocationUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    PortfolioAllocationUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    PortfolioAllocationUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    PortfolioAllocationScalarWhereInput: ["AND", "OR", "NOT", "id", "portfolioId", "assetId", "allocation", "createdAt", "updatedAt"],
+    EnvironmentVariableUpsertWithWhereUniqueWithoutPortfolioInput: ["where", "update", "create"],
+    EnvironmentVariableUpdateWithWhereUniqueWithoutPortfolioInput: ["where", "data"],
+    EnvironmentVariableUpdateManyWithWhereWithoutPortfolioInput: ["where", "data"],
+    EnvironmentVariableScalarWhereInput: ["AND", "OR", "NOT", "id", "key", "value", "description", "portfolioId", "createdAt", "updatedAt"],
+    UserCreateWithoutPortfoliosInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics"],
+    UserCreateOrConnectWithoutPortfoliosInput: ["where", "create"],
+    PortfolioCreateWithoutPortfolioUsersInput: ["id", "name", "description", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutPortfolioUsersInput: ["where", "create"],
+    UserUpsertWithoutPortfoliosInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutPortfoliosInput: ["where", "data"],
+    UserUpdateWithoutPortfoliosInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics"],
+    PortfolioUpsertWithoutPortfolioUsersInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutPortfolioUsersInput: ["where", "data"],
+    PortfolioUpdateWithoutPortfolioUsersInput: ["id", "name", "description", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateWithoutEnvironmentVariablesInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations"],
+    PortfolioCreateOrConnectWithoutEnvironmentVariablesInput: ["where", "create"],
+    PortfolioUpsertWithoutEnvironmentVariablesInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutEnvironmentVariablesInput: ["where", "data"],
+    PortfolioUpdateWithoutEnvironmentVariablesInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations"],
+    UserCreateWithoutCustomerInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutCustomerInput: ["where", "create"],
+    UserCreateManyCustomerInputEnvelope: ["data", "skipDuplicates"],
+    UserUpsertWithWhereUniqueWithoutCustomerInput: ["where", "update", "create"],
+    UserUpdateWithWhereUniqueWithoutCustomerInput: ["where", "data"],
+    UserUpdateManyWithWhereWithoutCustomerInput: ["where", "data"],
+    UserScalarWhereInput: ["AND", "OR", "NOT", "id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "customerId", "plan"],
+    HoldingCreateWithoutAssetInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "portfolio"],
+    HoldingCreateOrConnectWithoutAssetInput: ["where", "create"],
+    HoldingCreateManyAssetInputEnvelope: ["data", "skipDuplicates"],
+    TradeCreateWithoutAssetInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "steps"],
+    TradeCreateOrConnectWithoutAssetInput: ["where", "create"],
+    TradeCreateManyAssetInputEnvelope: ["data", "skipDuplicates"],
+    OrderCreateWithoutAssetInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "portfolio"],
+    OrderCreateOrConnectWithoutAssetInput: ["where", "create"],
+    OrderCreateManyAssetInputEnvelope: ["data", "skipDuplicates"],
+    AIRecommendationCreateWithoutAssetInput: ["id", "action", "confidence", "createdAt", "updatedAt", "user", "portfolio"],
+    AIRecommendationCreateOrConnectWithoutAssetInput: ["where", "create"],
+    AIRecommendationCreateManyAssetInputEnvelope: ["data", "skipDuplicates"],
+    NewsCreateWithoutAssetInput: ["id", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    NewsCreateOrConnectWithoutAssetInput: ["where", "create"],
+    NewsCreateManyAssetInputEnvelope: ["data", "skipDuplicates"],
+    PortfolioAllocationCreateWithoutAssetInput: ["id", "allocation", "createdAt", "updatedAt", "portfolio"],
+    PortfolioAllocationCreateOrConnectWithoutAssetInput: ["where", "create"],
+    PortfolioAllocationCreateManyAssetInputEnvelope: ["data", "skipDuplicates"],
+    HoldingUpsertWithWhereUniqueWithoutAssetInput: ["where", "update", "create"],
+    HoldingUpdateWithWhereUniqueWithoutAssetInput: ["where", "data"],
+    HoldingUpdateManyWithWhereWithoutAssetInput: ["where", "data"],
+    TradeUpsertWithWhereUniqueWithoutAssetInput: ["where", "update", "create"],
+    TradeUpdateWithWhereUniqueWithoutAssetInput: ["where", "data"],
+    TradeUpdateManyWithWhereWithoutAssetInput: ["where", "data"],
+    OrderUpsertWithWhereUniqueWithoutAssetInput: ["where", "update", "create"],
+    OrderUpdateWithWhereUniqueWithoutAssetInput: ["where", "data"],
+    OrderUpdateManyWithWhereWithoutAssetInput: ["where", "data"],
+    AIRecommendationUpsertWithWhereUniqueWithoutAssetInput: ["where", "update", "create"],
+    AIRecommendationUpdateWithWhereUniqueWithoutAssetInput: ["where", "data"],
+    AIRecommendationUpdateManyWithWhereWithoutAssetInput: ["where", "data"],
+    NewsUpsertWithWhereUniqueWithoutAssetInput: ["where", "update", "create"],
+    NewsUpdateWithWhereUniqueWithoutAssetInput: ["where", "data"],
+    NewsUpdateManyWithWhereWithoutAssetInput: ["where", "data"],
+    NewsScalarWhereInput: ["AND", "OR", "NOT", "id", "assetId", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    PortfolioAllocationUpsertWithWhereUniqueWithoutAssetInput: ["where", "update", "create"],
+    PortfolioAllocationUpdateWithWhereUniqueWithoutAssetInput: ["where", "data"],
+    PortfolioAllocationUpdateManyWithWhereWithoutAssetInput: ["where", "data"],
+    UserCreateWithoutHoldingsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutHoldingsInput: ["where", "create"],
+    PortfolioCreateWithoutHoldingsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutHoldingsInput: ["where", "create"],
+    AssetCreateWithoutHoldingsInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetCreateOrConnectWithoutHoldingsInput: ["where", "create"],
+    UserUpsertWithoutHoldingsInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutHoldingsInput: ["where", "data"],
+    UserUpdateWithoutHoldingsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    PortfolioUpsertWithoutHoldingsInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutHoldingsInput: ["where", "data"],
+    PortfolioUpdateWithoutHoldingsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    AssetUpsertWithoutHoldingsInput: ["update", "create", "where"],
+    AssetUpdateToOneWithWhereWithoutHoldingsInput: ["where", "data"],
+    AssetUpdateWithoutHoldingsInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "trades", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    UserCreateWithoutTradesInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutTradesInput: ["where", "create"],
+    PortfolioCreateWithoutTradesInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutTradesInput: ["where", "create"],
+    AssetCreateWithoutTradesInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetCreateOrConnectWithoutTradesInput: ["where", "create"],
+    TradeStepCreateWithoutTradeInput: ["id", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    TradeStepCreateOrConnectWithoutTradeInput: ["where", "create"],
+    TradeStepCreateManyTradeInputEnvelope: ["data", "skipDuplicates"],
+    UserUpsertWithoutTradesInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutTradesInput: ["where", "data"],
+    UserUpdateWithoutTradesInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    PortfolioUpsertWithoutTradesInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutTradesInput: ["where", "data"],
+    PortfolioUpdateWithoutTradesInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    AssetUpsertWithoutTradesInput: ["update", "create", "where"],
+    AssetUpdateToOneWithWhereWithoutTradesInput: ["where", "data"],
+    AssetUpdateWithoutTradesInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "orders", "aiRecommendations", "news", "PortfolioAllocation"],
+    TradeStepUpsertWithWhereUniqueWithoutTradeInput: ["where", "update", "create"],
+    TradeStepUpdateWithWhereUniqueWithoutTradeInput: ["where", "data"],
+    TradeStepUpdateManyWithWhereWithoutTradeInput: ["where", "data"],
+    TradeStepScalarWhereInput: ["AND", "OR", "NOT", "id", "tradeId", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    TradeCreateWithoutStepsInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "asset"],
+    TradeCreateOrConnectWithoutStepsInput: ["where", "create"],
+    TradeUpsertWithoutStepsInput: ["update", "create", "where"],
+    TradeUpdateToOneWithWhereWithoutStepsInput: ["where", "data"],
+    TradeUpdateWithoutStepsInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "asset"],
+    UserCreateWithoutOrdersInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutOrdersInput: ["where", "create"],
+    PortfolioCreateWithoutOrdersInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutOrdersInput: ["where", "create"],
+    AssetCreateWithoutOrdersInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "aiRecommendations", "news", "PortfolioAllocation"],
+    AssetCreateOrConnectWithoutOrdersInput: ["where", "create"],
+    UserUpsertWithoutOrdersInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutOrdersInput: ["where", "data"],
+    UserUpdateWithoutOrdersInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    PortfolioUpsertWithoutOrdersInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutOrdersInput: ["where", "data"],
+    PortfolioUpdateWithoutOrdersInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    AssetUpsertWithoutOrdersInput: ["update", "create", "where"],
+    AssetUpdateToOneWithWhereWithoutOrdersInput: ["where", "data"],
+    AssetUpdateWithoutOrdersInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "aiRecommendations", "news", "PortfolioAllocation"],
+    UserCreateWithoutAiRecommendationsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutAiRecommendationsInput: ["where", "create"],
+    PortfolioCreateWithoutAiRecommendationsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutAiRecommendationsInput: ["where", "create"],
+    AssetCreateWithoutAiRecommendationsInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "news", "PortfolioAllocation"],
+    AssetCreateOrConnectWithoutAiRecommendationsInput: ["where", "create"],
+    UserUpsertWithoutAiRecommendationsInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutAiRecommendationsInput: ["where", "data"],
+    UserUpdateWithoutAiRecommendationsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    PortfolioUpsertWithoutAiRecommendationsInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutAiRecommendationsInput: ["where", "data"],
+    PortfolioUpdateWithoutAiRecommendationsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "riskAllocations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    AssetUpsertWithoutAiRecommendationsInput: ["update", "create", "where"],
+    AssetUpdateToOneWithWhereWithoutAiRecommendationsInput: ["where", "data"],
+    AssetUpdateWithoutAiRecommendationsInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "news", "PortfolioAllocation"],
+    UserCreateWithoutRiskAllocationsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "alerts", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutRiskAllocationsInput: ["where", "create"],
+    PortfolioCreateWithoutRiskAllocationsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutRiskAllocationsInput: ["where", "create"],
+    UserUpsertWithoutRiskAllocationsInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutRiskAllocationsInput: ["where", "data"],
+    UserUpdateWithoutRiskAllocationsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "alerts", "portfolios", "performanceMetrics"],
+    PortfolioUpsertWithoutRiskAllocationsInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutRiskAllocationsInput: ["where", "data"],
+    PortfolioUpdateWithoutRiskAllocationsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "alerts", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    UserCreateWithoutAlertsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "portfolios", "performanceMetrics"],
+    UserCreateOrConnectWithoutAlertsInput: ["where", "create"],
+    PortfolioCreateWithoutAlertsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutAlertsInput: ["where", "create"],
+    UserUpsertWithoutAlertsInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutAlertsInput: ["where", "data"],
+    UserUpdateWithoutAlertsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "portfolios", "performanceMetrics"],
+    PortfolioUpsertWithoutAlertsInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutAlertsInput: ["where", "data"],
+    PortfolioUpdateWithoutAlertsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "performanceMetrics", "portfolioAllocations", "environmentVariables"],
+    AssetCreateWithoutNewsInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "PortfolioAllocation"],
+    AssetCreateOrConnectWithoutNewsInput: ["where", "create"],
+    AssetUpsertWithoutNewsInput: ["update", "create", "where"],
+    AssetUpdateToOneWithWhereWithoutNewsInput: ["where", "data"],
+    AssetUpdateWithoutNewsInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "PortfolioAllocation"],
+    PortfolioCreateWithoutPortfolioAllocationsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutPortfolioAllocationsInput: ["where", "create"],
+    AssetCreateWithoutPortfolioAllocationInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "news"],
+    AssetCreateOrConnectWithoutPortfolioAllocationInput: ["where", "create"],
+    PortfolioUpsertWithoutPortfolioAllocationsInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutPortfolioAllocationsInput: ["where", "data"],
+    PortfolioUpdateWithoutPortfolioAllocationsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "performanceMetrics", "environmentVariables"],
+    AssetUpsertWithoutPortfolioAllocationInput: ["update", "create", "where"],
+    AssetUpdateToOneWithWhereWithoutPortfolioAllocationInput: ["where", "data"],
+    AssetUpdateWithoutPortfolioAllocationInput: ["id", "symbol", "name", "type", "logoUrl", "createdAt", "updatedAt", "holdings", "trades", "orders", "aiRecommendations", "news"],
+    UserCreateWithoutPerformanceMetricsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios"],
+    UserCreateOrConnectWithoutPerformanceMetricsInput: ["where", "create"],
+    PortfolioCreateWithoutPerformanceMetricsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolioAllocations", "environmentVariables"],
+    PortfolioCreateOrConnectWithoutPerformanceMetricsInput: ["where", "create"],
+    UserUpsertWithoutPerformanceMetricsInput: ["update", "create", "where"],
+    UserUpdateToOneWithWhereWithoutPerformanceMetricsInput: ["where", "data"],
+    UserUpdateWithoutPerformanceMetricsInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "customer", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios"],
+    PortfolioUpsertWithoutPerformanceMetricsInput: ["update", "create", "where"],
+    PortfolioUpdateToOneWithWhereWithoutPerformanceMetricsInput: ["where", "data"],
+    PortfolioUpdateWithoutPerformanceMetricsInput: ["id", "name", "description", "createdAt", "updatedAt", "portfolioUsers", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolioAllocations", "environmentVariables"],
+    AccountCreateManyUserInput: ["id", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    SessionCreateManyUserInput: ["id", "sessionToken", "expires", "createdAt", "updatedAt"],
+    AuthenticatorCreateManyUserInput: ["id", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    HoldingCreateManyUserInput: ["id", "portfolioId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    TradeCreateManyUserInput: ["id", "portfolioId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    OrderCreateManyUserInput: ["id", "portfolioId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    AIRecommendationCreateManyUserInput: ["id", "portfolioId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    RiskAllocationCreateManyUserInput: ["id", "portfolioId", "assetType", "allocation", "createdAt", "updatedAt"],
+    AlertCreateManyUserInput: ["id", "portfolioId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    PortfolioUserCreateManyUserInput: ["id", "portfolioId", "role", "createdAt", "updatedAt"],
+    PerformanceMetricCreateManyUserInput: ["id", "portfolioId", "label", "value", "createdAt", "updatedAt"],
+    AccountUpdateWithoutUserInput: ["id", "type", "provider", "providerAccountId", "refresh_token", "access_token", "expires_at", "token_type", "scope", "id_token", "session_state", "createdAt", "updatedAt"],
+    SessionUpdateWithoutUserInput: ["id", "sessionToken", "expires", "createdAt", "updatedAt"],
+    AuthenticatorUpdateWithoutUserInput: ["id", "credentialID", "publicKey", "counter", "createdAt", "updatedAt"],
+    HoldingUpdateWithoutUserInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt", "portfolio", "asset"],
+    TradeUpdateWithoutUserInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "portfolio", "asset", "steps"],
+    OrderUpdateWithoutUserInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "portfolio", "asset"],
+    AIRecommendationUpdateWithoutUserInput: ["id", "action", "confidence", "createdAt", "updatedAt", "portfolio", "asset"],
+    RiskAllocationUpdateWithoutUserInput: ["id", "assetType", "allocation", "createdAt", "updatedAt", "portfolio"],
+    AlertUpdateWithoutUserInput: ["id", "message", "type", "isRead", "createdAt", "updatedAt", "portfolio"],
+    PortfolioUserUpdateWithoutUserInput: ["id", "role", "createdAt", "updatedAt", "portfolio"],
+    PerformanceMetricUpdateWithoutUserInput: ["id", "label", "value", "createdAt", "updatedAt", "portfolio"],
+    PortfolioUserCreateManyPortfolioInput: ["id", "userId", "role", "createdAt", "updatedAt"],
+    HoldingCreateManyPortfolioInput: ["id", "userId", "assetId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    TradeCreateManyPortfolioInput: ["id", "userId", "assetId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    OrderCreateManyPortfolioInput: ["id", "userId", "assetId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    AIRecommendationCreateManyPortfolioInput: ["id", "userId", "assetId", "action", "confidence", "createdAt", "updatedAt"],
+    RiskAllocationCreateManyPortfolioInput: ["id", "userId", "assetType", "allocation", "createdAt", "updatedAt"],
+    AlertCreateManyPortfolioInput: ["id", "userId", "message", "type", "isRead", "createdAt", "updatedAt"],
+    PerformanceMetricCreateManyPortfolioInput: ["id", "userId", "label", "value", "createdAt", "updatedAt"],
+    PortfolioAllocationCreateManyPortfolioInput: ["id", "assetId", "allocation", "createdAt", "updatedAt"],
+    EnvironmentVariableCreateManyPortfolioInput: ["id", "key", "value", "description", "createdAt", "updatedAt"],
+    PortfolioUserUpdateWithoutPortfolioInput: ["id", "role", "createdAt", "updatedAt", "user"],
+    HoldingUpdateWithoutPortfolioInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "asset"],
+    TradeUpdateWithoutPortfolioInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "asset", "steps"],
+    OrderUpdateWithoutPortfolioInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "asset"],
+    AIRecommendationUpdateWithoutPortfolioInput: ["id", "action", "confidence", "createdAt", "updatedAt", "user", "asset"],
+    RiskAllocationUpdateWithoutPortfolioInput: ["id", "assetType", "allocation", "createdAt", "updatedAt", "user"],
+    AlertUpdateWithoutPortfolioInput: ["id", "message", "type", "isRead", "createdAt", "updatedAt", "user"],
+    PerformanceMetricUpdateWithoutPortfolioInput: ["id", "label", "value", "createdAt", "updatedAt", "user"],
+    PortfolioAllocationUpdateWithoutPortfolioInput: ["id", "allocation", "createdAt", "updatedAt", "asset"],
+    EnvironmentVariableUpdateWithoutPortfolioInput: ["id", "key", "value", "description", "createdAt", "updatedAt"],
+    UserCreateManyCustomerInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan"],
+    UserUpdateWithoutCustomerInput: ["id", "name", "email", "emailVerified", "image", "createdAt", "updatedAt", "role", "bio", "jobTitle", "currentPortfolio", "plan", "accounts", "sessions", "authenticators", "holdings", "trades", "orders", "aiRecommendations", "riskAllocations", "alerts", "portfolios", "performanceMetrics"],
+    HoldingCreateManyAssetInput: ["id", "userId", "portfolioId", "quantity", "averagePrice", "createdAt", "updatedAt"],
+    TradeCreateManyAssetInput: ["id", "userId", "portfolioId", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status"],
+    OrderCreateManyAssetInput: ["id", "userId", "portfolioId", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt"],
+    AIRecommendationCreateManyAssetInput: ["id", "userId", "portfolioId", "action", "confidence", "createdAt", "updatedAt"],
+    NewsCreateManyAssetInput: ["id", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    PortfolioAllocationCreateManyAssetInput: ["id", "portfolioId", "allocation", "createdAt", "updatedAt"],
+    HoldingUpdateWithoutAssetInput: ["id", "quantity", "averagePrice", "createdAt", "updatedAt", "user", "portfolio"],
+    TradeUpdateWithoutAssetInput: ["id", "action", "quantity", "price", "total", "timestamp", "createdAt", "updatedAt", "status", "user", "portfolio", "steps"],
+    OrderUpdateWithoutAssetInput: ["id", "type", "action", "quantity", "price", "status", "createdAt", "updatedAt", "user", "portfolio"],
+    AIRecommendationUpdateWithoutAssetInput: ["id", "action", "confidence", "createdAt", "updatedAt", "user", "portfolio"],
+    NewsUpdateWithoutAssetInput: ["id", "title", "content", "source", "url", "sentiment", "publishedAt", "createdAt", "updatedAt"],
+    PortfolioAllocationUpdateWithoutAssetInput: ["id", "allocation", "createdAt", "updatedAt", "portfolio"],
+    TradeStepCreateManyTradeInput: ["id", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"],
+    TradeStepUpdateWithoutTradeInput: ["id", "sequence", "action", "hedgeType", "hedgePrice", "buyPrice", "sellPrice", "qty", "side", "type", "stopLoss", "targetPrice", "note", "executionTime", "status", "fee"]
+};
+function applyInputTypesEnhanceMap(inputTypesEnhanceMap) {
+    for (const inputTypeEnhanceMapKey of Object.keys(inputTypesEnhanceMap)) {
+        const inputTypeName = inputTypeEnhanceMapKey;
+        const typeConfig = inputTypesEnhanceMap[inputTypeName];
+        const typeClass = inputTypes[inputTypeName];
+        const typeTarget = typeClass.prototype;
+        applyTypeClassEnhanceConfig(typeConfig, typeClass, typeTarget, inputsInfo[inputTypeName]);
+    }
+}
+//# sourceMappingURL=enhance.js.map