Gitead/DentalManagementMH05
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add provider column, commission tracking, and report provider filter

Browse Source 
- Claims & Payments: save npiProviderId when submitting MH claim; sync between claim and payment on update
- Claims table: add Provider column showing rendering provider name
- Payments table: add Provider column + purple Commissioned badge on status
- Claim edit modal: add Rendering Provider dropdown (defaults to Mary Scannell)
- Payment edit modal: add Rendering Provider dropdown + Commissioned metadata display
- Reports page: add Provider filter dropdown (dynamic from NPI providers settings)
- Reports page: remove Collections by Doctor report type and Select Doctor dropdown
- Commission section: new section in reports page with date range + provider filter, shows eligible paid claims/payments per provider, multi-select checkboxes, Pay Commission modal with print + save, marks payments as commissioned so they are excluded from future cycles
- DB: add CommissionBatch and CommissionBatchItem tables; backfill Payment.npiProviderId from linked claims
- Backend: PATCH /api/payments/:id/provider syncs to linked claim; PUT /api/claims/:id syncs to linked payment; new /api/commissions routes

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Gitead
2026-05-15 23:51:39 -04:00
parent 25a20e8a16
commit 7360b1930b
366 changed files with 10822 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
packages/db/shared/schemas/objects/CommissionBatchArgs.schema.ts Normal file
View File

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchSelectObjectSchema as CommissionBatchSelectObjectSchema } from './CommissionBatchSelect.schema';
import { CommissionBatchIncludeObjectSchema as CommissionBatchIncludeObjectSchema } from './CommissionBatchInclude.schema'
const makeSchema = () => z.object({
select: z.lazy(() => CommissionBatchSelectObjectSchema).optional(),
include: z.lazy(() => CommissionBatchIncludeObjectSchema).optional()
}).strict();
export const CommissionBatchArgsObjectSchema = makeSchema();
export const CommissionBatchArgsObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchAvgAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
npiProviderId: z.literal(true).optional(),
totalCollection: z.literal(true).optional(),
commissionAmount: z.literal(true).optional()
}).strict();
export const CommissionBatchAvgAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchAvgAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchAvgAggregateInputType>;
export const CommissionBatchAvgAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchAvgOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
npiProviderId: SortOrderSchema.optional(),
totalCollection: SortOrderSchema.optional(),
commissionAmount: SortOrderSchema.optional()
}).strict();
export const CommissionBatchAvgOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchAvgOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchAvgOrderByAggregateInput>;
export const CommissionBatchAvgOrderByAggregateInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/CommissionBatchCountAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
npiProviderId: z.literal(true).optional(),
totalCollection: z.literal(true).optional(),
commissionAmount: z.literal(true).optional(),
notes: z.literal(true).optional(),
createdAt: z.literal(true).optional(),
_all: z.literal(true).optional()
}).strict();
export const CommissionBatchCountAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchCountAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCountAggregateInputType>;
export const CommissionBatchCountAggregateInputObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/CommissionBatchCountOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
npiProviderId: SortOrderSchema.optional(),
totalCollection: SortOrderSchema.optional(),
commissionAmount: SortOrderSchema.optional(),
notes: SortOrderSchema.optional(),
createdAt: SortOrderSchema.optional()
}).strict();
export const CommissionBatchCountOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchCountOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCountOrderByAggregateInput>;
export const CommissionBatchCountOrderByAggregateInputObjectZodSchema = makeSchema();

9
packages/db/shared/schemas/objects/CommissionBatchCountOutputTypeArgs.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchCountOutputTypeSelectObjectSchema as CommissionBatchCountOutputTypeSelectObjectSchema } from './CommissionBatchCountOutputTypeSelect.schema'
const makeSchema = () => z.object({
select: z.lazy(() => CommissionBatchCountOutputTypeSelectObjectSchema).optional()
}).strict();
export const CommissionBatchCountOutputTypeArgsObjectSchema = makeSchema();
export const CommissionBatchCountOutputTypeArgsObjectZodSchema = makeSchema();

9
packages/db/shared/schemas/objects/CommissionBatchCountOutputTypeCountItemsArgs.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemWhereInputObjectSchema as CommissionBatchItemWhereInputObjectSchema } from './CommissionBatchItemWhereInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemWhereInputObjectSchema).optional()
}).strict();
export const CommissionBatchCountOutputTypeCountItemsArgsObjectSchema = makeSchema();
export const CommissionBatchCountOutputTypeCountItemsArgsObjectZodSchema = makeSchema();

9
packages/db/shared/schemas/objects/CommissionBatchCountOutputTypeSelect.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchCountOutputTypeCountItemsArgsObjectSchema as CommissionBatchCountOutputTypeCountItemsArgsObjectSchema } from './CommissionBatchCountOutputTypeCountItemsArgs.schema'
const makeSchema = () => z.object({
items: z.union([z.boolean(), z.lazy(() => CommissionBatchCountOutputTypeCountItemsArgsObjectSchema)]).optional()
}).strict();
export const CommissionBatchCountOutputTypeSelectObjectSchema: z.ZodType<Prisma.CommissionBatchCountOutputTypeSelect> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCountOutputTypeSelect>;
export const CommissionBatchCountOutputTypeSelectObjectZodSchema = makeSchema();

33
packages/db/shared/schemas/objects/CommissionBatchCreateInput.schema.ts Normal file
View File

@@ -0,0 +1,33 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { NpiProviderCreateNestedOneWithoutCommissionBatchesInputObjectSchema as NpiProviderCreateNestedOneWithoutCommissionBatchesInputObjectSchema } from './NpiProviderCreateNestedOneWithoutCommissionBatchesInput.schema';
import { CommissionBatchItemCreateNestedManyWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateNestedManyWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateNestedManyWithoutCommissionBatchInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
totalCollection: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}),
commissionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}),
notes: z.string().optional().nullable(),
createdAt: z.coerce.date().optional(),
npiProvider: z.lazy(() => NpiProviderCreateNestedOneWithoutCommissionBatchesInputObjectSchema),
items: z.lazy(() => CommissionBatchItemCreateNestedManyWithoutCommissionBatchInputObjectSchema).optional()
}).strict();
export const CommissionBatchCreateInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateInput>;
export const CommissionBatchCreateInputObjectZodSchema = makeSchema();

32
packages/db/shared/schemas/objects/CommissionBatchCreateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,32 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
npiProviderId: z.number().int(),
totalCollection: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}),
commissionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}),
notes: z.string().optional().nullable(),
createdAt: z.coerce.date().optional()
}).strict();
export const CommissionBatchCreateManyInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateManyInput>;
export const CommissionBatchCreateManyInputObjectZodSchema = makeSchema();

31
packages/db/shared/schemas/objects/CommissionBatchCreateManyNpiProviderInput.schema.ts Normal file
View File

@@ -0,0 +1,31 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
totalCollection: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}),
commissionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}),
notes: z.string().optional().nullable(),
createdAt: z.coerce.date().optional()
}).strict();
export const CommissionBatchCreateManyNpiProviderInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateManyNpiProviderInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateManyNpiProviderInput>;
export const CommissionBatchCreateManyNpiProviderInputObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/CommissionBatchCreateManyNpiProviderInputEnvelope.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchCreateManyNpiProviderInputObjectSchema as CommissionBatchCreateManyNpiProviderInputObjectSchema } from './CommissionBatchCreateManyNpiProviderInput.schema'
const makeSchema = () => z.object({
data: z.union([z.lazy(() => CommissionBatchCreateManyNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchCreateManyNpiProviderInputObjectSchema).array()]),
skipDuplicates: z.boolean().optional()
}).strict();
export const CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema: z.ZodType<Prisma.CommissionBatchCreateManyNpiProviderInputEnvelope> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateManyNpiProviderInputEnvelope>;
export const CommissionBatchCreateManyNpiProviderInputEnvelopeObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/CommissionBatchCreateNestedManyWithoutNpiProviderInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchCreateWithoutNpiProviderInputObjectSchema as CommissionBatchCreateWithoutNpiProviderInputObjectSchema } from './CommissionBatchCreateWithoutNpiProviderInput.schema';
import { CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema as CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema } from './CommissionBatchUncheckedCreateWithoutNpiProviderInput.schema';
import { CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema as CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema } from './CommissionBatchCreateOrConnectWithoutNpiProviderInput.schema';
import { CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema as CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema } from './CommissionBatchCreateManyNpiProviderInputEnvelope.schema';
import { CommissionBatchWhereUniqueInputObjectSchema as CommissionBatchWhereUniqueInputObjectSchema } from './CommissionBatchWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchCreateWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchCreateWithoutNpiProviderInputObjectSchema).array(), z.lazy(() => CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchCreateNestedManyWithoutNpiProviderInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateNestedManyWithoutNpiProviderInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateNestedManyWithoutNpiProviderInput>;
export const CommissionBatchCreateNestedManyWithoutNpiProviderInputObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/CommissionBatchCreateNestedOneWithoutItemsInput.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchCreateWithoutItemsInputObjectSchema as CommissionBatchCreateWithoutItemsInputObjectSchema } from './CommissionBatchCreateWithoutItemsInput.schema';
import { CommissionBatchUncheckedCreateWithoutItemsInputObjectSchema as CommissionBatchUncheckedCreateWithoutItemsInputObjectSchema } from './CommissionBatchUncheckedCreateWithoutItemsInput.schema';
import { CommissionBatchCreateOrConnectWithoutItemsInputObjectSchema as CommissionBatchCreateOrConnectWithoutItemsInputObjectSchema } from './CommissionBatchCreateOrConnectWithoutItemsInput.schema';
import { CommissionBatchWhereUniqueInputObjectSchema as CommissionBatchWhereUniqueInputObjectSchema } from './CommissionBatchWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchCreateWithoutItemsInputObjectSchema), z.lazy(() => CommissionBatchUncheckedCreateWithoutItemsInputObjectSchema)]).optional(),
connectOrCreate: z.lazy(() => CommissionBatchCreateOrConnectWithoutItemsInputObjectSchema).optional(),
connect: z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema).optional()
}).strict();
export const CommissionBatchCreateNestedOneWithoutItemsInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateNestedOneWithoutItemsInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateNestedOneWithoutItemsInput>;
export const CommissionBatchCreateNestedOneWithoutItemsInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchCreateOrConnectWithoutItemsInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchWhereUniqueInputObjectSchema as CommissionBatchWhereUniqueInputObjectSchema } from './CommissionBatchWhereUniqueInput.schema';
import { CommissionBatchCreateWithoutItemsInputObjectSchema as CommissionBatchCreateWithoutItemsInputObjectSchema } from './CommissionBatchCreateWithoutItemsInput.schema';
import { CommissionBatchUncheckedCreateWithoutItemsInputObjectSchema as CommissionBatchUncheckedCreateWithoutItemsInputObjectSchema } from './CommissionBatchUncheckedCreateWithoutItemsInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema),
create: z.union([z.lazy(() => CommissionBatchCreateWithoutItemsInputObjectSchema), z.lazy(() => CommissionBatchUncheckedCreateWithoutItemsInputObjectSchema)])
}).strict();
export const CommissionBatchCreateOrConnectWithoutItemsInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateOrConnectWithoutItemsInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateOrConnectWithoutItemsInput>;
export const CommissionBatchCreateOrConnectWithoutItemsInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchCreateOrConnectWithoutNpiProviderInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchWhereUniqueInputObjectSchema as CommissionBatchWhereUniqueInputObjectSchema } from './CommissionBatchWhereUniqueInput.schema';
import { CommissionBatchCreateWithoutNpiProviderInputObjectSchema as CommissionBatchCreateWithoutNpiProviderInputObjectSchema } from './CommissionBatchCreateWithoutNpiProviderInput.schema';
import { CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema as CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema } from './CommissionBatchUncheckedCreateWithoutNpiProviderInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema),
create: z.union([z.lazy(() => CommissionBatchCreateWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema)])
}).strict();
export const CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateOrConnectWithoutNpiProviderInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateOrConnectWithoutNpiProviderInput>;
export const CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectZodSchema = makeSchema();

31
packages/db/shared/schemas/objects/CommissionBatchCreateWithoutItemsInput.schema.ts Normal file
View File

@@ -0,0 +1,31 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { NpiProviderCreateNestedOneWithoutCommissionBatchesInputObjectSchema as NpiProviderCreateNestedOneWithoutCommissionBatchesInputObjectSchema } from './NpiProviderCreateNestedOneWithoutCommissionBatchesInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
totalCollection: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}),
commissionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}),
notes: z.string().optional().nullable(),
createdAt: z.coerce.date().optional(),
npiProvider: z.lazy(() => NpiProviderCreateNestedOneWithoutCommissionBatchesInputObjectSchema)
}).strict();
export const CommissionBatchCreateWithoutItemsInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateWithoutItemsInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateWithoutItemsInput>;
export const CommissionBatchCreateWithoutItemsInputObjectZodSchema = makeSchema();

31
packages/db/shared/schemas/objects/CommissionBatchCreateWithoutNpiProviderInput.schema.ts Normal file
View File

@@ -0,0 +1,31 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { CommissionBatchItemCreateNestedManyWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateNestedManyWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateNestedManyWithoutCommissionBatchInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
totalCollection: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}),
commissionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}),
notes: z.string().optional().nullable(),
createdAt: z.coerce.date().optional(),
items: z.lazy(() => CommissionBatchItemCreateNestedManyWithoutCommissionBatchInputObjectSchema).optional()
}).strict();
export const CommissionBatchCreateWithoutNpiProviderInputObjectSchema: z.ZodType<Prisma.CommissionBatchCreateWithoutNpiProviderInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchCreateWithoutNpiProviderInput>;
export const CommissionBatchCreateWithoutNpiProviderInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/CommissionBatchInclude.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { NpiProviderArgsObjectSchema as NpiProviderArgsObjectSchema } from './NpiProviderArgs.schema';
import { CommissionBatchItemFindManySchema as CommissionBatchItemFindManySchema } from '../findManyCommissionBatchItem.schema';
import { CommissionBatchCountOutputTypeArgsObjectSchema as CommissionBatchCountOutputTypeArgsObjectSchema } from './CommissionBatchCountOutputTypeArgs.schema'
const makeSchema = () => z.object({
npiProvider: z.union([z.boolean(), z.lazy(() => NpiProviderArgsObjectSchema)]).optional(),
items: z.union([z.boolean(), z.lazy(() => CommissionBatchItemFindManySchema)]).optional(),
_count: z.union([z.boolean(), z.lazy(() => CommissionBatchCountOutputTypeArgsObjectSchema)]).optional()
}).strict();
export const CommissionBatchIncludeObjectSchema: z.ZodType<Prisma.CommissionBatchInclude> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchInclude>;
export const CommissionBatchIncludeObjectZodSchema = makeSchema();

11
packages/db/shared/schemas/objects/CommissionBatchItemArgs.schema.ts Normal file
View File

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemSelectObjectSchema as CommissionBatchItemSelectObjectSchema } from './CommissionBatchItemSelect.schema';
import { CommissionBatchItemIncludeObjectSchema as CommissionBatchItemIncludeObjectSchema } from './CommissionBatchItemInclude.schema'
const makeSchema = () => z.object({
select: z.lazy(() => CommissionBatchItemSelectObjectSchema).optional(),
include: z.lazy(() => CommissionBatchItemIncludeObjectSchema).optional()
}).strict();
export const CommissionBatchItemArgsObjectSchema = makeSchema();
export const CommissionBatchItemArgsObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemAvgAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
commissionBatchId: z.literal(true).optional(),
paymentId: z.literal(true).optional(),
collectionAmount: z.literal(true).optional()
}).strict();
export const CommissionBatchItemAvgAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemAvgAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemAvgAggregateInputType>;
export const CommissionBatchItemAvgAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemAvgOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
commissionBatchId: SortOrderSchema.optional(),
paymentId: SortOrderSchema.optional(),
collectionAmount: SortOrderSchema.optional()
}).strict();
export const CommissionBatchItemAvgOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemAvgOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemAvgOrderByAggregateInput>;
export const CommissionBatchItemAvgOrderByAggregateInputObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInput.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
commissionBatchId: z.number().int(),
paymentId: z.number().int()
}).strict();
export const CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInput>;
export const CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/CommissionBatchItemCountAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
commissionBatchId: z.literal(true).optional(),
paymentId: z.literal(true).optional(),
collectionAmount: z.literal(true).optional(),
_all: z.literal(true).optional()
}).strict();
export const CommissionBatchItemCountAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCountAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCountAggregateInputType>;
export const CommissionBatchItemCountAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemCountOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
commissionBatchId: SortOrderSchema.optional(),
paymentId: SortOrderSchema.optional(),
collectionAmount: SortOrderSchema.optional()
}).strict();
export const CommissionBatchItemCountOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCountOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCountOrderByAggregateInput>;
export const CommissionBatchItemCountOrderByAggregateInputObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/CommissionBatchItemCreateInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { CommissionBatchCreateNestedOneWithoutItemsInputObjectSchema as CommissionBatchCreateNestedOneWithoutItemsInputObjectSchema } from './CommissionBatchCreateNestedOneWithoutItemsInput.schema';
import { PaymentCreateNestedOneWithoutCommissionBatchItemsInputObjectSchema as PaymentCreateNestedOneWithoutCommissionBatchItemsInputObjectSchema } from './PaymentCreateNestedOneWithoutCommissionBatchItemsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}),
commissionBatch: z.lazy(() => CommissionBatchCreateNestedOneWithoutItemsInputObjectSchema),
payment: z.lazy(() => PaymentCreateNestedOneWithoutCommissionBatchItemsInputObjectSchema)
}).strict();
export const CommissionBatchItemCreateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateInput>;
export const CommissionBatchItemCreateInputObjectZodSchema = makeSchema();

21
packages/db/shared/schemas/objects/CommissionBatchItemCreateManyCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
paymentId: z.number().int(),
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})
}).strict();
export const CommissionBatchItemCreateManyCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateManyCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateManyCommissionBatchInput>;
export const CommissionBatchItemCreateManyCommissionBatchInputObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/CommissionBatchItemCreateManyCommissionBatchInputEnvelope.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateManyCommissionBatchInputObjectSchema as CommissionBatchItemCreateManyCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateManyCommissionBatchInput.schema'
const makeSchema = () => z.object({
data: z.union([z.lazy(() => CommissionBatchItemCreateManyCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateManyCommissionBatchInputObjectSchema).array()]),
skipDuplicates: z.boolean().optional()
}).strict();
export const CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateManyCommissionBatchInputEnvelope> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateManyCommissionBatchInputEnvelope>;
export const CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/CommissionBatchItemCreateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
commissionBatchId: z.number().int(),
paymentId: z.number().int(),
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})
}).strict();
export const CommissionBatchItemCreateManyInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateManyInput>;
export const CommissionBatchItemCreateManyInputObjectZodSchema = makeSchema();

21
packages/db/shared/schemas/objects/CommissionBatchItemCreateManyPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
commissionBatchId: z.number().int(),
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})
}).strict();
export const CommissionBatchItemCreateManyPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateManyPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateManyPaymentInput>;
export const CommissionBatchItemCreateManyPaymentInputObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/CommissionBatchItemCreateManyPaymentInputEnvelope.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateManyPaymentInputObjectSchema as CommissionBatchItemCreateManyPaymentInputObjectSchema } from './CommissionBatchItemCreateManyPaymentInput.schema'
const makeSchema = () => z.object({
data: z.union([z.lazy(() => CommissionBatchItemCreateManyPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateManyPaymentInputObjectSchema).array()]),
skipDuplicates: z.boolean().optional()
}).strict();
export const CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateManyPaymentInputEnvelope> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateManyPaymentInputEnvelope>;
export const CommissionBatchItemCreateManyPaymentInputEnvelopeObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/CommissionBatchItemCreateNestedManyWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema as CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema } from './CommissionBatchItemCreateManyCommissionBatchInputEnvelope.schema';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema).array(), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchItemCreateNestedManyWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateNestedManyWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateNestedManyWithoutCommissionBatchInput>;
export const CommissionBatchItemCreateNestedManyWithoutCommissionBatchInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/CommissionBatchItemCreateNestedManyWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateWithoutPaymentInputObjectSchema as CommissionBatchItemCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateWithoutPaymentInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutPaymentInput.schema';
import { CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema as CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateOrConnectWithoutPaymentInput.schema';
import { CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema as CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema } from './CommissionBatchItemCreateManyPaymentInputEnvelope.schema';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema).array(), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchItemCreateNestedManyWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateNestedManyWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateNestedManyWithoutPaymentInput>;
export const CommissionBatchItemCreateNestedManyWithoutPaymentInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema),
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema)])
}).strict();
export const CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput>;
export const CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemCreateOrConnectWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemCreateWithoutPaymentInputObjectSchema as CommissionBatchItemCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateWithoutPaymentInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutPaymentInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema),
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema)])
}).strict();
export const CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateOrConnectWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateOrConnectWithoutPaymentInput>;
export const CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectZodSchema = makeSchema();

20
packages/db/shared/schemas/objects/CommissionBatchItemCreateWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,20 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { PaymentCreateNestedOneWithoutCommissionBatchItemsInputObjectSchema as PaymentCreateNestedOneWithoutCommissionBatchItemsInputObjectSchema } from './PaymentCreateNestedOneWithoutCommissionBatchItemsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}),
payment: z.lazy(() => PaymentCreateNestedOneWithoutCommissionBatchItemsInputObjectSchema)
}).strict();
export const CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateWithoutCommissionBatchInput>;
export const CommissionBatchItemCreateWithoutCommissionBatchInputObjectZodSchema = makeSchema();

20
packages/db/shared/schemas/objects/CommissionBatchItemCreateWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,20 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { CommissionBatchCreateNestedOneWithoutItemsInputObjectSchema as CommissionBatchCreateNestedOneWithoutItemsInputObjectSchema } from './CommissionBatchCreateNestedOneWithoutItemsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}),
commissionBatch: z.lazy(() => CommissionBatchCreateNestedOneWithoutItemsInputObjectSchema)
}).strict();
export const CommissionBatchItemCreateWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemCreateWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemCreateWithoutPaymentInput>;
export const CommissionBatchItemCreateWithoutPaymentInputObjectZodSchema = makeSchema();

11
packages/db/shared/schemas/objects/CommissionBatchItemInclude.schema.ts Normal file
View File

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchArgsObjectSchema as CommissionBatchArgsObjectSchema } from './CommissionBatchArgs.schema';
import { PaymentArgsObjectSchema as PaymentArgsObjectSchema } from './PaymentArgs.schema'
const makeSchema = () => z.object({
commissionBatch: z.union([z.boolean(), z.lazy(() => CommissionBatchArgsObjectSchema)]).optional(),
payment: z.union([z.boolean(), z.lazy(() => PaymentArgsObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemIncludeObjectSchema: z.ZodType<Prisma.CommissionBatchItemInclude> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemInclude>;
export const CommissionBatchItemIncludeObjectZodSchema = makeSchema();

11
packages/db/shared/schemas/objects/CommissionBatchItemListRelationFilter.schema.ts Normal file
View File

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemWhereInputObjectSchema as CommissionBatchItemWhereInputObjectSchema } from './CommissionBatchItemWhereInput.schema'
const makeSchema = () => z.object({
every: z.lazy(() => CommissionBatchItemWhereInputObjectSchema).optional(),
some: z.lazy(() => CommissionBatchItemWhereInputObjectSchema).optional(),
none: z.lazy(() => CommissionBatchItemWhereInputObjectSchema).optional()
}).strict();
export const CommissionBatchItemListRelationFilterObjectSchema: z.ZodType<Prisma.CommissionBatchItemListRelationFilter> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemListRelationFilter>;
export const CommissionBatchItemListRelationFilterObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemMaxAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
commissionBatchId: z.literal(true).optional(),
paymentId: z.literal(true).optional(),
collectionAmount: z.literal(true).optional()
}).strict();
export const CommissionBatchItemMaxAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemMaxAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemMaxAggregateInputType>;
export const CommissionBatchItemMaxAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemMaxOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
commissionBatchId: SortOrderSchema.optional(),
paymentId: SortOrderSchema.optional(),
collectionAmount: SortOrderSchema.optional()
}).strict();
export const CommissionBatchItemMaxOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemMaxOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemMaxOrderByAggregateInput>;
export const CommissionBatchItemMaxOrderByAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemMinAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
commissionBatchId: z.literal(true).optional(),
paymentId: z.literal(true).optional(),
collectionAmount: z.literal(true).optional()
}).strict();
export const CommissionBatchItemMinAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemMinAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemMinAggregateInputType>;
export const CommissionBatchItemMinAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemMinOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
commissionBatchId: SortOrderSchema.optional(),
paymentId: SortOrderSchema.optional(),
collectionAmount: SortOrderSchema.optional()
}).strict();
export const CommissionBatchItemMinOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemMinOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemMinOrderByAggregateInput>;
export const CommissionBatchItemMinOrderByAggregateInputObjectZodSchema = makeSchema();

9
packages/db/shared/schemas/objects/CommissionBatchItemOrderByRelationAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
_count: SortOrderSchema.optional()
}).strict();
export const CommissionBatchItemOrderByRelationAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemOrderByRelationAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemOrderByRelationAggregateInput>;
export const CommissionBatchItemOrderByRelationAggregateInputObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/CommissionBatchItemOrderByWithAggregationInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { CommissionBatchItemCountOrderByAggregateInputObjectSchema as CommissionBatchItemCountOrderByAggregateInputObjectSchema } from './CommissionBatchItemCountOrderByAggregateInput.schema';
import { CommissionBatchItemAvgOrderByAggregateInputObjectSchema as CommissionBatchItemAvgOrderByAggregateInputObjectSchema } from './CommissionBatchItemAvgOrderByAggregateInput.schema';
import { CommissionBatchItemMaxOrderByAggregateInputObjectSchema as CommissionBatchItemMaxOrderByAggregateInputObjectSchema } from './CommissionBatchItemMaxOrderByAggregateInput.schema';
import { CommissionBatchItemMinOrderByAggregateInputObjectSchema as CommissionBatchItemMinOrderByAggregateInputObjectSchema } from './CommissionBatchItemMinOrderByAggregateInput.schema';
import { CommissionBatchItemSumOrderByAggregateInputObjectSchema as CommissionBatchItemSumOrderByAggregateInputObjectSchema } from './CommissionBatchItemSumOrderByAggregateInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
commissionBatchId: SortOrderSchema.optional(),
paymentId: SortOrderSchema.optional(),
collectionAmount: SortOrderSchema.optional(),
_count: z.lazy(() => CommissionBatchItemCountOrderByAggregateInputObjectSchema).optional(),
_avg: z.lazy(() => CommissionBatchItemAvgOrderByAggregateInputObjectSchema).optional(),
_max: z.lazy(() => CommissionBatchItemMaxOrderByAggregateInputObjectSchema).optional(),
_min: z.lazy(() => CommissionBatchItemMinOrderByAggregateInputObjectSchema).optional(),
_sum: z.lazy(() => CommissionBatchItemSumOrderByAggregateInputObjectSchema).optional()
}).strict();
export const CommissionBatchItemOrderByWithAggregationInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemOrderByWithAggregationInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemOrderByWithAggregationInput>;
export const CommissionBatchItemOrderByWithAggregationInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/CommissionBatchItemOrderByWithRelationInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { CommissionBatchOrderByWithRelationInputObjectSchema as CommissionBatchOrderByWithRelationInputObjectSchema } from './CommissionBatchOrderByWithRelationInput.schema';
import { PaymentOrderByWithRelationInputObjectSchema as PaymentOrderByWithRelationInputObjectSchema } from './PaymentOrderByWithRelationInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
commissionBatchId: SortOrderSchema.optional(),
paymentId: SortOrderSchema.optional(),
collectionAmount: SortOrderSchema.optional(),
commissionBatch: z.lazy(() => CommissionBatchOrderByWithRelationInputObjectSchema).optional(),
payment: z.lazy(() => PaymentOrderByWithRelationInputObjectSchema).optional()
}).strict();
export const CommissionBatchItemOrderByWithRelationInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemOrderByWithRelationInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemOrderByWithRelationInput>;
export const CommissionBatchItemOrderByWithRelationInputObjectZodSchema = makeSchema();

26
packages/db/shared/schemas/objects/CommissionBatchItemScalarWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,26 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFilterObjectSchema as IntFilterObjectSchema } from './IntFilter.schema';
import { DecimalFilterObjectSchema as DecimalFilterObjectSchema } from './DecimalFilter.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const commissionbatchitemscalarwhereinputSchema = z.object({
AND: z.union([z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema).array()]).optional(),
OR: z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
commissionBatchId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
paymentId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
collectionAmount: z.union([z.lazy(() => DecimalFilterObjectSchema), z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})]).optional()
}).strict();
export const CommissionBatchItemScalarWhereInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemScalarWhereInput> = commissionbatchitemscalarwhereinputSchema as unknown as z.ZodType<Prisma.CommissionBatchItemScalarWhereInput>;
export const CommissionBatchItemScalarWhereInputObjectZodSchema = commissionbatchitemscalarwhereinputSchema;

26
packages/db/shared/schemas/objects/CommissionBatchItemScalarWhereWithAggregatesInput.schema.ts Normal file
View File

@@ -0,0 +1,26 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntWithAggregatesFilterObjectSchema as IntWithAggregatesFilterObjectSchema } from './IntWithAggregatesFilter.schema';
import { DecimalWithAggregatesFilterObjectSchema as DecimalWithAggregatesFilterObjectSchema } from './DecimalWithAggregatesFilter.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const commissionbatchitemscalarwherewithaggregatesinputSchema = z.object({
AND: z.union([z.lazy(() => CommissionBatchItemScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => CommissionBatchItemScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
OR: z.lazy(() => CommissionBatchItemScalarWhereWithAggregatesInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => CommissionBatchItemScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => CommissionBatchItemScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
commissionBatchId: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
paymentId: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
collectionAmount: z.union([z.lazy(() => DecimalWithAggregatesFilterObjectSchema), z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})]).optional()
}).strict();
export const CommissionBatchItemScalarWhereWithAggregatesInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemScalarWhereWithAggregatesInput> = commissionbatchitemscalarwherewithaggregatesinputSchema as unknown as z.ZodType<Prisma.CommissionBatchItemScalarWhereWithAggregatesInput>;
export const CommissionBatchItemScalarWhereWithAggregatesInputObjectZodSchema = commissionbatchitemscalarwherewithaggregatesinputSchema;

15
packages/db/shared/schemas/objects/CommissionBatchItemSelect.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchArgsObjectSchema as CommissionBatchArgsObjectSchema } from './CommissionBatchArgs.schema';
import { PaymentArgsObjectSchema as PaymentArgsObjectSchema } from './PaymentArgs.schema'
const makeSchema = () => z.object({
id: z.boolean().optional(),
commissionBatchId: z.boolean().optional(),
paymentId: z.boolean().optional(),
collectionAmount: z.boolean().optional(),
commissionBatch: z.union([z.boolean(), z.lazy(() => CommissionBatchArgsObjectSchema)]).optional(),
payment: z.union([z.boolean(), z.lazy(() => PaymentArgsObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemSelectObjectSchema: z.ZodType<Prisma.CommissionBatchItemSelect> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemSelect>;
export const CommissionBatchItemSelectObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemSumAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
commissionBatchId: z.literal(true).optional(),
paymentId: z.literal(true).optional(),
collectionAmount: z.literal(true).optional()
}).strict();
export const CommissionBatchItemSumAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemSumAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemSumAggregateInputType>;
export const CommissionBatchItemSumAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemSumOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
commissionBatchId: SortOrderSchema.optional(),
paymentId: SortOrderSchema.optional(),
collectionAmount: SortOrderSchema.optional()
}).strict();
export const CommissionBatchItemSumOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemSumOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemSumOrderByAggregateInput>;
export const CommissionBatchItemSumOrderByAggregateInputObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedCreateInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
commissionBatchId: z.number().int(),
paymentId: z.number().int(),
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})
}).strict();
export const CommissionBatchItemUncheckedCreateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedCreateInput>;
export const CommissionBatchItemUncheckedCreateInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema as CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema } from './CommissionBatchItemCreateManyCommissionBatchInputEnvelope.schema';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema).array(), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInput>;
export const CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateWithoutPaymentInputObjectSchema as CommissionBatchItemCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateWithoutPaymentInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutPaymentInput.schema';
import { CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema as CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateOrConnectWithoutPaymentInput.schema';
import { CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema as CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema } from './CommissionBatchItemCreateManyPaymentInputEnvelope.schema';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema).array(), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInput>;
export const CommissionBatchItemUncheckedCreateNestedManyWithoutPaymentInputObjectZodSchema = makeSchema();

21
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
paymentId: z.number().int(),
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})
}).strict();
export const CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput>;
export const CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectZodSchema = makeSchema();

21
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedCreateWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
commissionBatchId: z.number().int(),
collectionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})
}).strict();
export const CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedCreateWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedCreateWithoutPaymentInput>;
export const CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectZodSchema = makeSchema();

23
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,23 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionBatchId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
paymentId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemUncheckedUpdateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateInput>;
export const CommissionBatchItemUncheckedUpdateInputObjectZodSchema = makeSchema();

23
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedUpdateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,23 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionBatchId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
paymentId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemUncheckedUpdateManyInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyInput>;
export const CommissionBatchItemUncheckedUpdateManyInputObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
paymentId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInput>;
export const CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInputObjectZodSchema = makeSchema();

27
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema as CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema } from './CommissionBatchItemCreateManyCommissionBatchInputEnvelope.schema';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput.schema';
import { CommissionBatchItemScalarWhereInputObjectSchema as CommissionBatchItemScalarWhereInputObjectSchema } from './CommissionBatchItemScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema).array(), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInput>;
export const CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInputObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedUpdateManyWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionBatchId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemUncheckedUpdateManyWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyWithoutPaymentInput>;
export const CommissionBatchItemUncheckedUpdateManyWithoutPaymentInputObjectZodSchema = makeSchema();

27
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateWithoutPaymentInputObjectSchema as CommissionBatchItemCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateWithoutPaymentInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutPaymentInput.schema';
import { CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema as CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateOrConnectWithoutPaymentInput.schema';
import { CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema as CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema } from './CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput.schema';
import { CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema as CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema } from './CommissionBatchItemCreateManyPaymentInputEnvelope.schema';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema as CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema } from './CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput.schema';
import { CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema as CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema } from './CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput.schema';
import { CommissionBatchItemScalarWhereInputObjectSchema as CommissionBatchItemScalarWhereInputObjectSchema } from './CommissionBatchItemScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema).array(), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInput>;
export const CommissionBatchItemUncheckedUpdateManyWithoutPaymentNestedInputObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
paymentId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInput>;
export const CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInputObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/CommissionBatchItemUncheckedUpdateWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionBatchId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemUncheckedUpdateWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUncheckedUpdateWithoutPaymentInput>;
export const CommissionBatchItemUncheckedUpdateWithoutPaymentInputObjectZodSchema = makeSchema();

23
packages/db/shared/schemas/objects/CommissionBatchItemUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,23 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema';
import { CommissionBatchUpdateOneRequiredWithoutItemsNestedInputObjectSchema as CommissionBatchUpdateOneRequiredWithoutItemsNestedInputObjectSchema } from './CommissionBatchUpdateOneRequiredWithoutItemsNestedInput.schema';
import { PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInputObjectSchema as PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInputObjectSchema } from './PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionBatch: z.lazy(() => CommissionBatchUpdateOneRequiredWithoutItemsNestedInputObjectSchema).optional(),
payment: z.lazy(() => PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInputObjectSchema).optional()
}).strict();
export const CommissionBatchItemUpdateInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateInput>;
export const CommissionBatchItemUpdateInputObjectZodSchema = makeSchema();

19
packages/db/shared/schemas/objects/CommissionBatchItemUpdateManyMutationInput.schema.ts Normal file
View File

@@ -0,0 +1,19 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemUpdateManyMutationInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateManyMutationInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateManyMutationInput>;
export const CommissionBatchItemUpdateManyMutationInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemScalarWhereInputObjectSchema as CommissionBatchItemScalarWhereInputObjectSchema } from './CommissionBatchItemScalarWhereInput.schema';
import { CommissionBatchItemUpdateManyMutationInputObjectSchema as CommissionBatchItemUpdateManyMutationInputObjectSchema } from './CommissionBatchItemUpdateManyMutationInput.schema';
import { CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema),
data: z.union([z.lazy(() => CommissionBatchItemUpdateManyMutationInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchInputObjectSchema)])
}).strict();
export const CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput>;
export const CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemScalarWhereInputObjectSchema as CommissionBatchItemScalarWhereInputObjectSchema } from './CommissionBatchItemScalarWhereInput.schema';
import { CommissionBatchItemUpdateManyMutationInputObjectSchema as CommissionBatchItemUpdateManyMutationInputObjectSchema } from './CommissionBatchItemUpdateManyMutationInput.schema';
import { CommissionBatchItemUncheckedUpdateManyWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedUpdateManyWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedUpdateManyWithoutPaymentInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema),
data: z.union([z.lazy(() => CommissionBatchItemUpdateManyMutationInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedUpdateManyWithoutPaymentInputObjectSchema)])
}).strict();
export const CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput>;
export const CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectZodSchema = makeSchema();

27
packages/db/shared/schemas/objects/CommissionBatchItemUpdateManyWithoutCommissionBatchNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateOrConnectWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema as CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema } from './CommissionBatchItemCreateManyCommissionBatchInputEnvelope.schema';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInput.schema';
import { CommissionBatchItemScalarWhereInputObjectSchema as CommissionBatchItemScalarWhereInputObjectSchema } from './CommissionBatchItemScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema).array(), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemCreateOrConnectWithoutCommissionBatchInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchItemCreateManyCommissionBatchInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUpdateManyWithWhereWithoutCommissionBatchInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchItemUpdateManyWithoutCommissionBatchNestedInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateManyWithoutCommissionBatchNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateManyWithoutCommissionBatchNestedInput>;
export const CommissionBatchItemUpdateManyWithoutCommissionBatchNestedInputObjectZodSchema = makeSchema();

27
packages/db/shared/schemas/objects/CommissionBatchItemUpdateManyWithoutPaymentNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCreateWithoutPaymentInputObjectSchema as CommissionBatchItemCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateWithoutPaymentInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutPaymentInput.schema';
import { CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema as CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateOrConnectWithoutPaymentInput.schema';
import { CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema as CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema } from './CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput.schema';
import { CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema as CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema } from './CommissionBatchItemCreateManyPaymentInputEnvelope.schema';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema as CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema } from './CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput.schema';
import { CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema as CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema } from './CommissionBatchItemUpdateManyWithWhereWithoutPaymentInput.schema';
import { CommissionBatchItemScalarWhereInputObjectSchema as CommissionBatchItemScalarWhereInputObjectSchema } from './CommissionBatchItemScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema).array(), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemCreateOrConnectWithoutPaymentInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchItemCreateManyPaymentInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUpdateManyWithWhereWithoutPaymentInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchItemScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchItemUpdateManyWithoutPaymentNestedInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateManyWithoutPaymentNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateManyWithoutPaymentNestedInput>;
export const CommissionBatchItemUpdateManyWithoutPaymentNestedInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemUpdateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUpdateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUpdateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema),
data: z.union([z.lazy(() => CommissionBatchItemUpdateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInputObjectSchema)])
}).strict();
export const CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInput>;
export const CommissionBatchItemUpdateWithWhereUniqueWithoutCommissionBatchInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemUpdateWithoutPaymentInputObjectSchema as CommissionBatchItemUpdateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUpdateWithoutPaymentInput.schema';
import { CommissionBatchItemUncheckedUpdateWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedUpdateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedUpdateWithoutPaymentInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema),
data: z.union([z.lazy(() => CommissionBatchItemUpdateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedUpdateWithoutPaymentInputObjectSchema)])
}).strict();
export const CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInput>;
export const CommissionBatchItemUpdateWithWhereUniqueWithoutPaymentInputObjectZodSchema = makeSchema();

21
packages/db/shared/schemas/objects/CommissionBatchItemUpdateWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema';
import { PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInputObjectSchema as PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInputObjectSchema } from './PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
payment: z.lazy(() => PaymentUpdateOneRequiredWithoutCommissionBatchItemsNestedInputObjectSchema).optional()
}).strict();
export const CommissionBatchItemUpdateWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateWithoutCommissionBatchInput>;
export const CommissionBatchItemUpdateWithoutCommissionBatchInputObjectZodSchema = makeSchema();

21
packages/db/shared/schemas/objects/CommissionBatchItemUpdateWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema';
import { CommissionBatchUpdateOneRequiredWithoutItemsNestedInputObjectSchema as CommissionBatchUpdateOneRequiredWithoutItemsNestedInputObjectSchema } from './CommissionBatchUpdateOneRequiredWithoutItemsNestedInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
collectionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionBatch: z.lazy(() => CommissionBatchUpdateOneRequiredWithoutItemsNestedInputObjectSchema).optional()
}).strict();
export const CommissionBatchItemUpdateWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpdateWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpdateWithoutPaymentInput>;
export const CommissionBatchItemUpdateWithoutPaymentInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemUpdateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUpdateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUpdateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemCreateWithoutCommissionBatchInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutCommissionBatchInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema),
update: z.union([z.lazy(() => CommissionBatchItemUpdateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedUpdateWithoutCommissionBatchInputObjectSchema)]),
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutCommissionBatchInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutCommissionBatchInputObjectSchema)])
}).strict();
export const CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInput>;
export const CommissionBatchItemUpsertWithWhereUniqueWithoutCommissionBatchInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemWhereUniqueInputObjectSchema as CommissionBatchItemWhereUniqueInputObjectSchema } from './CommissionBatchItemWhereUniqueInput.schema';
import { CommissionBatchItemUpdateWithoutPaymentInputObjectSchema as CommissionBatchItemUpdateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUpdateWithoutPaymentInput.schema';
import { CommissionBatchItemUncheckedUpdateWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedUpdateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedUpdateWithoutPaymentInput.schema';
import { CommissionBatchItemCreateWithoutPaymentInputObjectSchema as CommissionBatchItemCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemCreateWithoutPaymentInput.schema';
import { CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema as CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema } from './CommissionBatchItemUncheckedCreateWithoutPaymentInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => CommissionBatchItemWhereUniqueInputObjectSchema),
update: z.union([z.lazy(() => CommissionBatchItemUpdateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedUpdateWithoutPaymentInputObjectSchema)]),
create: z.union([z.lazy(() => CommissionBatchItemCreateWithoutPaymentInputObjectSchema), z.lazy(() => CommissionBatchItemUncheckedCreateWithoutPaymentInputObjectSchema)])
}).strict();
export const CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInput>;
export const CommissionBatchItemUpsertWithWhereUniqueWithoutPaymentInputObjectZodSchema = makeSchema();

32
packages/db/shared/schemas/objects/CommissionBatchItemWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,32 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFilterObjectSchema as IntFilterObjectSchema } from './IntFilter.schema';
import { DecimalFilterObjectSchema as DecimalFilterObjectSchema } from './DecimalFilter.schema';
import { CommissionBatchScalarRelationFilterObjectSchema as CommissionBatchScalarRelationFilterObjectSchema } from './CommissionBatchScalarRelationFilter.schema';
import { CommissionBatchWhereInputObjectSchema as CommissionBatchWhereInputObjectSchema } from './CommissionBatchWhereInput.schema';
import { PaymentScalarRelationFilterObjectSchema as PaymentScalarRelationFilterObjectSchema } from './PaymentScalarRelationFilter.schema';
import { PaymentWhereInputObjectSchema as PaymentWhereInputObjectSchema } from './PaymentWhereInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const commissionbatchitemwhereinputSchema = z.object({
AND: z.union([z.lazy(() => CommissionBatchItemWhereInputObjectSchema), z.lazy(() => CommissionBatchItemWhereInputObjectSchema).array()]).optional(),
OR: z.lazy(() => CommissionBatchItemWhereInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => CommissionBatchItemWhereInputObjectSchema), z.lazy(() => CommissionBatchItemWhereInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
commissionBatchId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
paymentId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
collectionAmount: z.union([z.lazy(() => DecimalFilterObjectSchema), z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'collectionAmount' must be a Decimal",
})]).optional(),
commissionBatch: z.union([z.lazy(() => CommissionBatchScalarRelationFilterObjectSchema), z.lazy(() => CommissionBatchWhereInputObjectSchema)]).optional(),
payment: z.union([z.lazy(() => PaymentScalarRelationFilterObjectSchema), z.lazy(() => PaymentWhereInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchItemWhereInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemWhereInput> = commissionbatchitemwhereinputSchema as unknown as z.ZodType<Prisma.CommissionBatchItemWhereInput>;
export const CommissionBatchItemWhereInputObjectZodSchema = commissionbatchitemwhereinputSchema;

10
packages/db/shared/schemas/objects/CommissionBatchItemWhereUniqueInput.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInputObjectSchema as CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInputObjectSchema } from './CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
commissionBatchId_paymentId: z.lazy(() => CommissionBatchItemCommissionBatchIdPaymentIdCompoundUniqueInputObjectSchema).optional()
}).strict();
export const CommissionBatchItemWhereUniqueInputObjectSchema: z.ZodType<Prisma.CommissionBatchItemWhereUniqueInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchItemWhereUniqueInput>;
export const CommissionBatchItemWhereUniqueInputObjectZodSchema = makeSchema();

11
packages/db/shared/schemas/objects/CommissionBatchListRelationFilter.schema.ts Normal file
View File

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchWhereInputObjectSchema as CommissionBatchWhereInputObjectSchema } from './CommissionBatchWhereInput.schema'
const makeSchema = () => z.object({
every: z.lazy(() => CommissionBatchWhereInputObjectSchema).optional(),
some: z.lazy(() => CommissionBatchWhereInputObjectSchema).optional(),
none: z.lazy(() => CommissionBatchWhereInputObjectSchema).optional()
}).strict();
export const CommissionBatchListRelationFilterObjectSchema: z.ZodType<Prisma.CommissionBatchListRelationFilter> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchListRelationFilter>;
export const CommissionBatchListRelationFilterObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/CommissionBatchMaxAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
npiProviderId: z.literal(true).optional(),
totalCollection: z.literal(true).optional(),
commissionAmount: z.literal(true).optional(),
notes: z.literal(true).optional(),
createdAt: z.literal(true).optional()
}).strict();
export const CommissionBatchMaxAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchMaxAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchMaxAggregateInputType>;
export const CommissionBatchMaxAggregateInputObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/CommissionBatchMaxOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
npiProviderId: SortOrderSchema.optional(),
totalCollection: SortOrderSchema.optional(),
commissionAmount: SortOrderSchema.optional(),
notes: SortOrderSchema.optional(),
createdAt: SortOrderSchema.optional()
}).strict();
export const CommissionBatchMaxOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchMaxOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchMaxOrderByAggregateInput>;
export const CommissionBatchMaxOrderByAggregateInputObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/CommissionBatchMinAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
npiProviderId: z.literal(true).optional(),
totalCollection: z.literal(true).optional(),
commissionAmount: z.literal(true).optional(),
notes: z.literal(true).optional(),
createdAt: z.literal(true).optional()
}).strict();
export const CommissionBatchMinAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchMinAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchMinAggregateInputType>;
export const CommissionBatchMinAggregateInputObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/CommissionBatchMinOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
npiProviderId: SortOrderSchema.optional(),
totalCollection: SortOrderSchema.optional(),
commissionAmount: SortOrderSchema.optional(),
notes: SortOrderSchema.optional(),
createdAt: SortOrderSchema.optional()
}).strict();
export const CommissionBatchMinOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchMinOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchMinOrderByAggregateInput>;
export const CommissionBatchMinOrderByAggregateInputObjectZodSchema = makeSchema();

9
packages/db/shared/schemas/objects/CommissionBatchOrderByRelationAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
_count: SortOrderSchema.optional()
}).strict();
export const CommissionBatchOrderByRelationAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchOrderByRelationAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchOrderByRelationAggregateInput>;
export const CommissionBatchOrderByRelationAggregateInputObjectZodSchema = makeSchema();

25
packages/db/shared/schemas/objects/CommissionBatchOrderByWithAggregationInput.schema.ts Normal file
View File

@@ -0,0 +1,25 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { SortOrderInputObjectSchema as SortOrderInputObjectSchema } from './SortOrderInput.schema';
import { CommissionBatchCountOrderByAggregateInputObjectSchema as CommissionBatchCountOrderByAggregateInputObjectSchema } from './CommissionBatchCountOrderByAggregateInput.schema';
import { CommissionBatchAvgOrderByAggregateInputObjectSchema as CommissionBatchAvgOrderByAggregateInputObjectSchema } from './CommissionBatchAvgOrderByAggregateInput.schema';
import { CommissionBatchMaxOrderByAggregateInputObjectSchema as CommissionBatchMaxOrderByAggregateInputObjectSchema } from './CommissionBatchMaxOrderByAggregateInput.schema';
import { CommissionBatchMinOrderByAggregateInputObjectSchema as CommissionBatchMinOrderByAggregateInputObjectSchema } from './CommissionBatchMinOrderByAggregateInput.schema';
import { CommissionBatchSumOrderByAggregateInputObjectSchema as CommissionBatchSumOrderByAggregateInputObjectSchema } from './CommissionBatchSumOrderByAggregateInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
npiProviderId: SortOrderSchema.optional(),
totalCollection: SortOrderSchema.optional(),
commissionAmount: SortOrderSchema.optional(),
notes: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
createdAt: SortOrderSchema.optional(),
_count: z.lazy(() => CommissionBatchCountOrderByAggregateInputObjectSchema).optional(),
_avg: z.lazy(() => CommissionBatchAvgOrderByAggregateInputObjectSchema).optional(),
_max: z.lazy(() => CommissionBatchMaxOrderByAggregateInputObjectSchema).optional(),
_min: z.lazy(() => CommissionBatchMinOrderByAggregateInputObjectSchema).optional(),
_sum: z.lazy(() => CommissionBatchSumOrderByAggregateInputObjectSchema).optional()
}).strict();
export const CommissionBatchOrderByWithAggregationInputObjectSchema: z.ZodType<Prisma.CommissionBatchOrderByWithAggregationInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchOrderByWithAggregationInput>;
export const CommissionBatchOrderByWithAggregationInputObjectZodSchema = makeSchema();

19
packages/db/shared/schemas/objects/CommissionBatchOrderByWithRelationInput.schema.ts Normal file
View File

@@ -0,0 +1,19 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { SortOrderInputObjectSchema as SortOrderInputObjectSchema } from './SortOrderInput.schema';
import { NpiProviderOrderByWithRelationInputObjectSchema as NpiProviderOrderByWithRelationInputObjectSchema } from './NpiProviderOrderByWithRelationInput.schema';
import { CommissionBatchItemOrderByRelationAggregateInputObjectSchema as CommissionBatchItemOrderByRelationAggregateInputObjectSchema } from './CommissionBatchItemOrderByRelationAggregateInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
npiProviderId: SortOrderSchema.optional(),
totalCollection: SortOrderSchema.optional(),
commissionAmount: SortOrderSchema.optional(),
notes: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
createdAt: SortOrderSchema.optional(),
npiProvider: z.lazy(() => NpiProviderOrderByWithRelationInputObjectSchema).optional(),
items: z.lazy(() => CommissionBatchItemOrderByRelationAggregateInputObjectSchema).optional()
}).strict();
export const CommissionBatchOrderByWithRelationInputObjectSchema: z.ZodType<Prisma.CommissionBatchOrderByWithRelationInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchOrderByWithRelationInput>;
export const CommissionBatchOrderByWithRelationInputObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/CommissionBatchScalarRelationFilter.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchWhereInputObjectSchema as CommissionBatchWhereInputObjectSchema } from './CommissionBatchWhereInput.schema'
const makeSchema = () => z.object({
is: z.lazy(() => CommissionBatchWhereInputObjectSchema).optional(),
isNot: z.lazy(() => CommissionBatchWhereInputObjectSchema).optional()
}).strict();
export const CommissionBatchScalarRelationFilterObjectSchema: z.ZodType<Prisma.CommissionBatchScalarRelationFilter> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchScalarRelationFilter>;
export const CommissionBatchScalarRelationFilterObjectZodSchema = makeSchema();

38
packages/db/shared/schemas/objects/CommissionBatchScalarWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,38 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFilterObjectSchema as IntFilterObjectSchema } from './IntFilter.schema';
import { DecimalFilterObjectSchema as DecimalFilterObjectSchema } from './DecimalFilter.schema';
import { StringNullableFilterObjectSchema as StringNullableFilterObjectSchema } from './StringNullableFilter.schema';
import { DateTimeFilterObjectSchema as DateTimeFilterObjectSchema } from './DateTimeFilter.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const commissionbatchscalarwhereinputSchema = z.object({
AND: z.union([z.lazy(() => CommissionBatchScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchScalarWhereInputObjectSchema).array()]).optional(),
OR: z.lazy(() => CommissionBatchScalarWhereInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => CommissionBatchScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchScalarWhereInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
npiProviderId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
totalCollection: z.union([z.lazy(() => DecimalFilterObjectSchema), z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
})]).optional(),
commissionAmount: z.union([z.lazy(() => DecimalFilterObjectSchema), z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
})]).optional(),
notes: z.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()]).optional().nullable(),
createdAt: z.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()]).optional()
}).strict();
export const CommissionBatchScalarWhereInputObjectSchema: z.ZodType<Prisma.CommissionBatchScalarWhereInput> = commissionbatchscalarwhereinputSchema as unknown as z.ZodType<Prisma.CommissionBatchScalarWhereInput>;
export const CommissionBatchScalarWhereInputObjectZodSchema = commissionbatchscalarwhereinputSchema;

38
packages/db/shared/schemas/objects/CommissionBatchScalarWhereWithAggregatesInput.schema.ts Normal file
View File

@@ -0,0 +1,38 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntWithAggregatesFilterObjectSchema as IntWithAggregatesFilterObjectSchema } from './IntWithAggregatesFilter.schema';
import { DecimalWithAggregatesFilterObjectSchema as DecimalWithAggregatesFilterObjectSchema } from './DecimalWithAggregatesFilter.schema';
import { StringNullableWithAggregatesFilterObjectSchema as StringNullableWithAggregatesFilterObjectSchema } from './StringNullableWithAggregatesFilter.schema';
import { DateTimeWithAggregatesFilterObjectSchema as DateTimeWithAggregatesFilterObjectSchema } from './DateTimeWithAggregatesFilter.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const commissionbatchscalarwherewithaggregatesinputSchema = z.object({
AND: z.union([z.lazy(() => CommissionBatchScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => CommissionBatchScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
OR: z.lazy(() => CommissionBatchScalarWhereWithAggregatesInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => CommissionBatchScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => CommissionBatchScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
npiProviderId: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
totalCollection: z.union([z.lazy(() => DecimalWithAggregatesFilterObjectSchema), z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
})]).optional(),
commissionAmount: z.union([z.lazy(() => DecimalWithAggregatesFilterObjectSchema), z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
})]).optional(),
notes: z.union([z.lazy(() => StringNullableWithAggregatesFilterObjectSchema), z.string()]).optional().nullable(),
createdAt: z.union([z.lazy(() => DateTimeWithAggregatesFilterObjectSchema), z.coerce.date()]).optional()
}).strict();
export const CommissionBatchScalarWhereWithAggregatesInputObjectSchema: z.ZodType<Prisma.CommissionBatchScalarWhereWithAggregatesInput> = commissionbatchscalarwherewithaggregatesinputSchema as unknown as z.ZodType<Prisma.CommissionBatchScalarWhereWithAggregatesInput>;
export const CommissionBatchScalarWhereWithAggregatesInputObjectZodSchema = commissionbatchscalarwherewithaggregatesinputSchema;

19
packages/db/shared/schemas/objects/CommissionBatchSelect.schema.ts Normal file
View File

@@ -0,0 +1,19 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { NpiProviderArgsObjectSchema as NpiProviderArgsObjectSchema } from './NpiProviderArgs.schema';
import { CommissionBatchItemFindManySchema as CommissionBatchItemFindManySchema } from '../findManyCommissionBatchItem.schema';
import { CommissionBatchCountOutputTypeArgsObjectSchema as CommissionBatchCountOutputTypeArgsObjectSchema } from './CommissionBatchCountOutputTypeArgs.schema'
const makeSchema = () => z.object({
id: z.boolean().optional(),
npiProviderId: z.boolean().optional(),
totalCollection: z.boolean().optional(),
commissionAmount: z.boolean().optional(),
notes: z.boolean().optional(),
createdAt: z.boolean().optional(),
npiProvider: z.union([z.boolean(), z.lazy(() => NpiProviderArgsObjectSchema)]).optional(),
items: z.union([z.boolean(), z.lazy(() => CommissionBatchItemFindManySchema)]).optional(),
_count: z.union([z.boolean(), z.lazy(() => CommissionBatchCountOutputTypeArgsObjectSchema)]).optional()
}).strict();
export const CommissionBatchSelectObjectSchema: z.ZodType<Prisma.CommissionBatchSelect> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchSelect>;
export const CommissionBatchSelectObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchSumAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
npiProviderId: z.literal(true).optional(),
totalCollection: z.literal(true).optional(),
commissionAmount: z.literal(true).optional()
}).strict();
export const CommissionBatchSumAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchSumAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchSumAggregateInputType>;
export const CommissionBatchSumAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/CommissionBatchSumOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
npiProviderId: SortOrderSchema.optional(),
totalCollection: SortOrderSchema.optional(),
commissionAmount: SortOrderSchema.optional()
}).strict();
export const CommissionBatchSumOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CommissionBatchSumOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchSumOrderByAggregateInput>;
export const CommissionBatchSumOrderByAggregateInputObjectZodSchema = makeSchema();

33
packages/db/shared/schemas/objects/CommissionBatchUncheckedCreateInput.schema.ts Normal file
View File

@@ -0,0 +1,33 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
npiProviderId: z.number().int(),
totalCollection: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}),
commissionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}),
notes: z.string().optional().nullable(),
createdAt: z.coerce.date().optional(),
items: z.lazy(() => CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInputObjectSchema).optional()
}).strict();
export const CommissionBatchUncheckedCreateInputObjectSchema: z.ZodType<Prisma.CommissionBatchUncheckedCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchUncheckedCreateInput>;
export const CommissionBatchUncheckedCreateInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchCreateWithoutNpiProviderInputObjectSchema as CommissionBatchCreateWithoutNpiProviderInputObjectSchema } from './CommissionBatchCreateWithoutNpiProviderInput.schema';
import { CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema as CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema } from './CommissionBatchUncheckedCreateWithoutNpiProviderInput.schema';
import { CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema as CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema } from './CommissionBatchCreateOrConnectWithoutNpiProviderInput.schema';
import { CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema as CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema } from './CommissionBatchCreateManyNpiProviderInputEnvelope.schema';
import { CommissionBatchWhereUniqueInputObjectSchema as CommissionBatchWhereUniqueInputObjectSchema } from './CommissionBatchWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchCreateWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchCreateWithoutNpiProviderInputObjectSchema).array(), z.lazy(() => CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInputObjectSchema: z.ZodType<Prisma.CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInput>;
export const CommissionBatchUncheckedCreateNestedManyWithoutNpiProviderInputObjectZodSchema = makeSchema();

32
packages/db/shared/schemas/objects/CommissionBatchUncheckedCreateWithoutItemsInput.schema.ts Normal file
View File

@@ -0,0 +1,32 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
npiProviderId: z.number().int(),
totalCollection: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}),
commissionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}),
notes: z.string().optional().nullable(),
createdAt: z.coerce.date().optional()
}).strict();
export const CommissionBatchUncheckedCreateWithoutItemsInputObjectSchema: z.ZodType<Prisma.CommissionBatchUncheckedCreateWithoutItemsInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchUncheckedCreateWithoutItemsInput>;
export const CommissionBatchUncheckedCreateWithoutItemsInputObjectZodSchema = makeSchema();

32
packages/db/shared/schemas/objects/CommissionBatchUncheckedCreateWithoutNpiProviderInput.schema.ts Normal file
View File

@@ -0,0 +1,32 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInputObjectSchema as CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInputObjectSchema } from './CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.number().int().optional(),
totalCollection: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}),
commissionAmount: z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}),
notes: z.string().optional().nullable(),
createdAt: z.coerce.date().optional(),
items: z.lazy(() => CommissionBatchItemUncheckedCreateNestedManyWithoutCommissionBatchInputObjectSchema).optional()
}).strict();
export const CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema: z.ZodType<Prisma.CommissionBatchUncheckedCreateWithoutNpiProviderInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchUncheckedCreateWithoutNpiProviderInput>;
export const CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectZodSchema = makeSchema();

37
packages/db/shared/schemas/objects/CommissionBatchUncheckedUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,37 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInputObjectSchema as CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInputObjectSchema } from './CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
npiProviderId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
totalCollection: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
notes: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
items: z.lazy(() => CommissionBatchItemUncheckedUpdateManyWithoutCommissionBatchNestedInputObjectSchema).optional()
}).strict();
export const CommissionBatchUncheckedUpdateInputObjectSchema: z.ZodType<Prisma.CommissionBatchUncheckedUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchUncheckedUpdateInput>;
export const CommissionBatchUncheckedUpdateInputObjectZodSchema = makeSchema();

35
packages/db/shared/schemas/objects/CommissionBatchUncheckedUpdateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,35 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
npiProviderId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
totalCollection: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
notes: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchUncheckedUpdateManyInputObjectSchema: z.ZodType<Prisma.CommissionBatchUncheckedUpdateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchUncheckedUpdateManyInput>;
export const CommissionBatchUncheckedUpdateManyInputObjectZodSchema = makeSchema();

34
packages/db/shared/schemas/objects/CommissionBatchUncheckedUpdateManyWithoutNpiProviderInput.schema.ts Normal file
View File

@@ -0,0 +1,34 @@
import * as z from 'zod';
import { Prisma } from '../../../generated/prisma';
import Decimal from 'decimal.js';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { DecimalFieldUpdateOperationsInputObjectSchema as DecimalFieldUpdateOperationsInputObjectSchema } from './DecimalFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
import { DecimalJSLikeSchema, isValidDecimalInput } from '../../helpers/decimal-helpers';
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
totalCollection: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'totalCollection' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
commissionAmount: z.union([z.union([
z.number(),
z.string(),
z.instanceof(Decimal),
z.instanceof(Prisma.Decimal),
DecimalJSLikeSchema,
]).refine((v) => isValidDecimalInput(v), {
message: "Field 'commissionAmount' must be a Decimal",
}), z.lazy(() => DecimalFieldUpdateOperationsInputObjectSchema)]).optional(),
notes: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const CommissionBatchUncheckedUpdateManyWithoutNpiProviderInputObjectSchema: z.ZodType<Prisma.CommissionBatchUncheckedUpdateManyWithoutNpiProviderInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchUncheckedUpdateManyWithoutNpiProviderInput>;
export const CommissionBatchUncheckedUpdateManyWithoutNpiProviderInputObjectZodSchema = makeSchema();

27
packages/db/shared/schemas/objects/CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { CommissionBatchCreateWithoutNpiProviderInputObjectSchema as CommissionBatchCreateWithoutNpiProviderInputObjectSchema } from './CommissionBatchCreateWithoutNpiProviderInput.schema';
import { CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema as CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema } from './CommissionBatchUncheckedCreateWithoutNpiProviderInput.schema';
import { CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema as CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema } from './CommissionBatchCreateOrConnectWithoutNpiProviderInput.schema';
import { CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInputObjectSchema as CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInputObjectSchema } from './CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInput.schema';
import { CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema as CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema } from './CommissionBatchCreateManyNpiProviderInputEnvelope.schema';
import { CommissionBatchWhereUniqueInputObjectSchema as CommissionBatchWhereUniqueInputObjectSchema } from './CommissionBatchWhereUniqueInput.schema';
import { CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInputObjectSchema as CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInputObjectSchema } from './CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInput.schema';
import { CommissionBatchUpdateManyWithWhereWithoutNpiProviderInputObjectSchema as CommissionBatchUpdateManyWithWhereWithoutNpiProviderInputObjectSchema } from './CommissionBatchUpdateManyWithWhereWithoutNpiProviderInput.schema';
import { CommissionBatchScalarWhereInputObjectSchema as CommissionBatchScalarWhereInputObjectSchema } from './CommissionBatchScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => CommissionBatchCreateWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchCreateWithoutNpiProviderInputObjectSchema).array(), z.lazy(() => CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchUncheckedCreateWithoutNpiProviderInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchCreateOrConnectWithoutNpiProviderInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchUpsertWithWhereUniqueWithoutNpiProviderInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => CommissionBatchCreateManyNpiProviderInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema), z.lazy(() => CommissionBatchWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchUpdateWithWhereUniqueWithoutNpiProviderInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => CommissionBatchUpdateManyWithWhereWithoutNpiProviderInputObjectSchema), z.lazy(() => CommissionBatchUpdateManyWithWhereWithoutNpiProviderInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => CommissionBatchScalarWhereInputObjectSchema), z.lazy(() => CommissionBatchScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInputObjectSchema: z.ZodType<Prisma.CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInput>;
export const CommissionBatchUncheckedUpdateManyWithoutNpiProviderNestedInputObjectZodSchema = makeSchema();

Some files were not shown because too many files have changed in this diff Show More