@dragonmastery/dragoncore-shared 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1680 @@
+import { z } from "zod";
+
+//#region src/validation/app_settings/notification_emails_zod.ts
+/**
+* Schema for individual email entry
+*/
+const EmailEntrySchema = z.object({
+	id: z.string().default(() => `email-${Math.random().toString(36).substr(2, 9)}`).optional(),
+	email: z.string().email("Must be a valid email address")
+});
+/**
+* Schema for updating support ticket notification emails
+* Uses an array of email objects for proper validation and UX
+*/
+const UpdateNotificationEmailsSchema = z.object({ emails: z.array(EmailEntrySchema).max(10, "Maximum 10 email addresses allowed") });
+/**
+* Schema for reading support ticket notification emails
+*/
+const ReadNotificationEmailsSchema = z.object({ emails: z.array(z.object({ email: z.string() })) });
+/**
+* Helper function to create a new email entry
+*/
+function createNewEmailEntry() {
+	return {
+		id: `email-${Math.random().toString(36).substr(2, 9)}`,
+		email: ""
+	};
+}
+
+//#endregion
+//#region src/validation/attachment/attachment_filters_zod.ts
+const AttachmentFiltersSchema = z.object({
+	record_id: z.string(),
+	record_type: z.string(),
+	filters: z.object({
+		start_date: z.string().optional().nullable(),
+		end_date: z.string().optional().nullable(),
+		limit: z.number().optional().nullable(),
+		cursor: z.string().optional().nullable(),
+		folder_id: z.string().optional().nullable(),
+		include_folders: z.boolean().optional().default(true)
+	}).optional().nullable()
+});
+
+//#endregion
+//#region src/validation/attachment/attachment_folder_input_zod.ts
+const AttachmentFolderBaseSchema = z.object({
+	record_id: z.string(),
+	record_type: z.string(),
+	sanitized_name: z.string(),
+	original_name: z.string(),
+	description: z.string().optional().nullable(),
+	metadata: z.string().optional().nullable(),
+	parent_folder_id: z.string().optional().nullable(),
+	file_count: z.number().optional()
+});
+const AttachmentFolderCreateSchema = AttachmentFolderBaseSchema;
+const AttachmentFolderUpdateSchema = AttachmentFolderBaseSchema.extend({
+	id: z.string(),
+	record_id: z.string().optional(),
+	record_type: z.string().optional(),
+	sanitized_name: z.string().optional(),
+	original_name: z.string().optional(),
+	parent_folder_id: z.string().optional().nullable()
+});
+
+//#endregion
+//#region src/validation/attachment/attachment_folder_read_zod.ts
+const AttachmentFolderReadSchema = AttachmentFolderCreateSchema.extend({
+	id: z.string(),
+	file_count: z.number().optional(),
+	created_at: z.string(),
+	created_by: z.string(),
+	updated_at: z.string().optional().nullable(),
+	updated_by: z.string().optional().nullable(),
+	archived_at: z.string().optional().nullable(),
+	archived_by: z.string().optional().nullable(),
+	deleted_at: z.string().optional().nullable(),
+	deleted_by: z.string().optional().nullable()
+});
+
+//#endregion
+//#region src/validation/attachment/attachment_input_zod.ts
+const AttachmentBaseSchema = z.object({
+	record_id: z.string(),
+	record_type: z.string(),
+	sanitized_name: z.string(),
+	original_name: z.string(),
+	content_type: z.string(),
+	file_size: z.string(),
+	description: z.string().optional().nullable(),
+	metadata: z.string().optional().nullable(),
+	folder_id: z.string().optional().nullable()
+});
+const AttachmentCreateSchema = AttachmentBaseSchema;
+const AttachmentUpdateSchema = AttachmentBaseSchema.extend({
+	id: z.string(),
+	record_id: z.string().optional(),
+	record_type: z.string().optional(),
+	sanitized_name: z.string().optional(),
+	original_name: z.string().optional(),
+	content_type: z.string().optional(),
+	file_size: z.string().optional(),
+	folder_id: z.string().optional().nullable()
+});
+
+//#endregion
+//#region src/validation/attachment/attachment_read_zod.ts
+const AttachmentReadSchema = AttachmentCreateSchema.extend({
+	id: z.string(),
+	created_at: z.string(),
+	created_by: z.string(),
+	updated_at: z.string().optional().nullable(),
+	updated_by: z.string().optional().nullable(),
+	archived_at: z.string().optional().nullable(),
+	archived_by: z.string().optional().nullable(),
+	deleted_at: z.string().optional().nullable(),
+	deleted_by: z.string().optional().nullable()
+});
+
+//#endregion
+//#region src/validation/attachment/attachment_page_zod.ts
+const AttachmentPageSchema = z.object({
+	files: z.array(AttachmentReadSchema),
+	folders: z.array(AttachmentFolderReadSchema),
+	pageInfo: z.object({
+		hasNextPage: z.boolean(),
+		endCursor: z.string().optional().nullable()
+	})
+});
+
+//#endregion
+//#region src/validation/login_zod.ts
+const isCommonPassword = (password) => {
+	return [
+		"password",
+		"12345678",
+		"qwerty123",
+		"admin1234"
+	].includes(password.toLowerCase());
+};
+const passwordSchema = z.string().min(8, { message: "Password must be at least 8 characters long" }).max(64, { message: "Password must not exceed 64 characters" }).refine((password) => !/^\s|\s$/.test(password), { message: "Password must not have leading or trailing whitespace" }).refine((password) => !isCommonPassword(password), { message: "Password is too common and easily guessed" });
+const loginSchema = z.object({
+	email: z.string().trim().toLowerCase().min(3, "Please enter your email.").email("The email address is badly formatted."),
+	password: passwordSchema
+});
+
+//#endregion
+//#region src/validation/change_password_zod.ts
+const changePasswordSchema = z.object({ passwords: z.object({
+	current_password: z.string().min(8).max(64),
+	new_password: passwordSchema,
+	new_password_confirm: z.string()
+}).refine((data) => data.new_password === data.new_password_confirm, {
+	message: "Passwords do not match",
+	path: ["new_password_confirm"]
+}).refine((data) => data.new_password !== data.current_password, {
+	message: "New password must be different from current password",
+	path: ["new_password"]
+}) });
+
+//#endregion
+//#region src/validation/common/filter_operators_zod.ts
+/**
+* Individual operator constants - use these instead of string literals
+* All operators use shorthand names for URL compatibility
+*/
+const OPERATORS = {
+	EQUALS: "eq",
+	NOT_EQUALS: "ne",
+	GREATER_THAN: "gt",
+	GREATER_THAN_OR_EQUAL: "gte",
+	LESS_THAN: "lt",
+	LESS_THAN_OR_EQUAL: "lte",
+	BETWEEN: "between",
+	CONTAINS: "contains",
+	STARTS_WITH: "sw",
+	ENDS_WITH: "ew",
+	IS_ONE_OF: "in",
+	IS_NOT_ONE_OF: "notIn",
+	IS_EMPTY: "isEmpty",
+	IS_NOT_EMPTY: "isNotEmpty"
+};
+/**
+* String operators - shorthand names for URL compatibility
+* Only operators that make sense for string filtering
+*/
+const StringOperatorSchema = z.enum([
+	OPERATORS.EQUALS,
+	OPERATORS.NOT_EQUALS,
+	OPERATORS.CONTAINS,
+	OPERATORS.STARTS_WITH,
+	OPERATORS.ENDS_WITH,
+	OPERATORS.IS_ONE_OF,
+	OPERATORS.IS_NOT_ONE_OF
+]);
+/**
+* Date operators - shorthand names for URL compatibility
+* Only operators that make sense for date filtering
+*/
+const DateOperatorSchema = z.enum([
+	OPERATORS.EQUALS,
+	OPERATORS.NOT_EQUALS,
+	OPERATORS.GREATER_THAN,
+	OPERATORS.GREATER_THAN_OR_EQUAL,
+	OPERATORS.LESS_THAN,
+	OPERATORS.LESS_THAN_OR_EQUAL,
+	OPERATORS.BETWEEN,
+	OPERATORS.IS_EMPTY,
+	OPERATORS.IS_NOT_EMPTY
+]);
+/**
+* Number operators - shorthand names for URL compatibility
+* Only operators that make sense for number filtering
+*/
+const NumberOperatorSchema = z.enum([
+	OPERATORS.EQUALS,
+	OPERATORS.NOT_EQUALS,
+	OPERATORS.GREATER_THAN,
+	OPERATORS.GREATER_THAN_OR_EQUAL,
+	OPERATORS.LESS_THAN,
+	OPERATORS.LESS_THAN_OR_EQUAL,
+	OPERATORS.BETWEEN,
+	OPERATORS.IS_ONE_OF,
+	OPERATORS.IS_NOT_ONE_OF
+]);
+/**
+* Shared operator enum for equality comparisons (used by boolean and enum filters)
+*/
+const EqualityOperatorSchema = z.enum([OPERATORS.EQUALS, OPERATORS.NOT_EQUALS]);
+/**
+* Shared operator enum for equality and array operations (used by enum filters)
+*/
+const EqualityArrayOperatorSchema = z.enum([
+	OPERATORS.EQUALS,
+	OPERATORS.NOT_EQUALS,
+	OPERATORS.IS_ONE_OF,
+	OPERATORS.IS_NOT_ONE_OF
+]);
+/**
+* Data type enum for filters (spec-compliant)
+*/
+const DataTypeSchema = z.enum([
+	"string",
+	"number",
+	"date",
+	"boolean",
+	"enum",
+	"money",
+	"percentage"
+]);
+/**
+* Base filter schema - spec-compliant structure
+* Field name is the object key, not part of the filter object
+* All filters must include: operator
+* Optional: value, values, caseSensitive
+* Type is inferred from registry using the field name (object key)
+*/
+const BaseFilterSchema = z.object({
+	operator: z.string(),
+	value: z.any().optional(),
+	values: z.array(z.any()).optional(),
+	caseSensitive: z.boolean().optional()
+});
+/**
+* String filter input - Spec-compliant structure
+* Restricted operators: only operators that make sense for string filtering
+* Field name is the object key, type is inferred from registry
+*
+* Examples:
+* - Equality: { operator: "eq", value: "search" }
+* - Contains: { operator: "contains", value: "search", caseSensitive: false }
+* - Starts with: { operator: "sw", value: "prefix" }
+* - In array: { operator: "in", values: ["option1", "option2"] }
+*/
+const StringFilterSchema = BaseFilterSchema.extend({
+	operator: StringOperatorSchema,
+	value: z.string().optional(),
+	values: z.array(z.string()).optional(),
+	caseSensitive: z.boolean().optional()
+}).refine((data) => {
+	if (data.operator === OPERATORS.IS_ONE_OF || data.operator === OPERATORS.IS_NOT_ONE_OF) return data.values !== void 0 && data.values.length > 0;
+	return data.value !== void 0;
+}, { message: "value is required for non-array operators, values array is required for in/notIn" });
+/**
+* Boolean filter input - Spec-compliant structure
+* Field name is the object key, type is inferred from registry
+*
+* Examples:
+* - Equality: { operator: "eq", value: true }
+* - Not equals: { operator: "ne", value: false }
+*/
+const BooleanFilterSchema = BaseFilterSchema.extend({
+	operator: EqualityOperatorSchema,
+	value: z.boolean()
+});
+/**
+* Number filter input - Spec-compliant structure
+* Restricted operators: only operators that make sense for number filtering
+* Useful for ranges (credits > 100, priority <= 3, etc.)
+*
+* Examples:
+* - Equality: { field: "age", operator: "eq", value: 100, type: "number" }
+* - Greater than: { field: "price", operator: "gt", value: 100, type: "number" }
+* - Range: { field: "score", operator: "gte", value: 50, type: "number" }
+* - In array: { field: "priority", operator: "in", values: [1, 2, 3], type: "number" }
+*/
+const NumberFilterSchema = BaseFilterSchema.extend({
+	operator: NumberOperatorSchema,
+	value: z.number().optional(),
+	values: z.array(z.number()).optional()
+}).refine((data) => {
+	if (data.operator === OPERATORS.BETWEEN) return data.values !== void 0 && data.values.length === 2;
+	if (data.operator === OPERATORS.IS_ONE_OF || data.operator === OPERATORS.IS_NOT_ONE_OF) return data.values !== void 0 && data.values.length > 0;
+	return data.value !== void 0;
+}, { message: "value is required for non-array operators, values array is required for in/notIn, exactly 2 values required for between" }).refine((data) => {
+	if (data.operator === OPERATORS.BETWEEN && data.values && data.values.length === 2) {
+		const [min, max] = data.values;
+		return min !== void 0 && max !== void 0 && min <= max;
+	}
+	return true;
+}, {
+	message: "For between operator, values[0] must be less than or equal to values[1]",
+	path: ["values"]
+});
+/**
+* Date/DateTime string filter - Spec-compliant structure
+* Restricted operators: only operators that make sense for date filtering
+* Dates should be in ISO 8601 format: YYYY-MM-DD or full datetime
+*
+* Examples:
+* - Exact match: { field: "createdAt", operator: "eq", value: "2024-01-01", type: "date" }
+* - After date: { field: "expiresAt", operator: "gte", value: "2024-01-01", type: "date" }
+* - Before date: { field: "deadline", operator: "lt", value: "2024-12-31", type: "date" }
+* - Is empty: { field: "deletedAt", operator: "isEmpty", type: "date" } // No value property
+* - Is not empty: { field: "publishedAt", operator: "isNotEmpty", type: "date" } // No value property
+*/
+const DateFilterSchema = z.union([
+	BaseFilterSchema.extend({ operator: z.enum([OPERATORS.IS_EMPTY, OPERATORS.IS_NOT_EMPTY]) }).refine((data) => data.value === void 0 && data.values === void 0, { message: "isEmpty and isNotEmpty operators must not have value or values properties" }),
+	BaseFilterSchema.extend({
+		operator: z.literal(OPERATORS.BETWEEN),
+		values: z.array(z.string()).length(2)
+	}).refine((data) => data.values !== void 0 && data.values.length === 2, { message: "between operator requires exactly 2 values" }).refine((data) => {
+		if (data.values && data.values.length === 2) {
+			const [startDate, endDate] = data.values;
+			if (startDate !== void 0 && endDate !== void 0) return new Date(startDate) <= new Date(endDate);
+		}
+		return true;
+	}, {
+		message: "For between operator, values[0] must represent an earlier or equal date/time compared to values[1]",
+		path: ["values"]
+	}),
+	BaseFilterSchema.extend({
+		operator: z.enum([
+			OPERATORS.EQUALS,
+			OPERATORS.NOT_EQUALS,
+			OPERATORS.GREATER_THAN,
+			OPERATORS.GREATER_THAN_OR_EQUAL,
+			OPERATORS.LESS_THAN,
+			OPERATORS.LESS_THAN_OR_EQUAL
+		]),
+		value: z.string()
+	}).refine((data) => data.value !== void 0, { message: "value is required for non-null operators" })
+]);
+/**
+* Enum filter input - Spec-compliant structure
+* Supports both single value (eq/ne) and multiple values (in/notIn)
+* Field name is the object key, type is inferred from registry
+*
+* Usage: createEnumFilter(MyEnumSchema)
+*
+* Examples:
+* - Equality: { operator: "eq", value: "OPTION_A" }
+* - Not equals: { operator: "ne", value: "OPTION_B" }
+* - In array: { operator: "in", values: ["OPTION_A", "OPTION_B"] }
+* - Not in array: { operator: "notIn", values: ["OPTION_C", "OPTION_D"] }
+*/
+function createEnumFilter(enumSchema) {
+	return BaseFilterSchema.extend({
+		operator: EqualityArrayOperatorSchema,
+		value: enumSchema.optional(),
+		values: z.array(enumSchema).optional()
+	}).refine((data) => {
+		if (data.operator === OPERATORS.IS_ONE_OF || data.operator === OPERATORS.IS_NOT_ONE_OF) return data.values !== void 0 && data.values.length > 0;
+		return data.value !== void 0;
+	}, { message: "value is required for non-array operators, values array is required for in/notIn" });
+}
+/**
+* Filter configuration - Spec-compliant structure
+* Uses a flat object mapping field names to filter value objects
+* Field name is the object key, type is inferred from registry
+* All filters are combined with implicit AND logic
+* OR logic within a single field is supported through isOneOf/isNotOneOf operators
+*
+* Examples:
+* {
+*   "status": { operator: "eq", value: "active" },
+*   "age": { operator: "gt", value: 18 }
+* }
+*/
+const FilterConfigSchema = z.record(z.string(), BaseFilterSchema);
+
+//#endregion
+//#region src/validation/common/pagination_zod.ts
+/**
+* Sort direction enum
+*/
+const SortDirectionSchema = z.enum(["asc", "desc"]);
+const PaginationFiltersSchema = z.object({
+	first: z.number().min(1).max(100).optional(),
+	after: z.string().optional(),
+	sortBy: z.string().optional(),
+	sortDirection: SortDirectionSchema.optional(),
+	paginationToken: z.string().optional()
+});
+const PageInfoSchema = z.object({
+	hasNextPage: z.boolean(),
+	hasPreviousPage: z.boolean(),
+	prevPageCursor: z.string().optional(),
+	nextPageCursor: z.string().optional(),
+	currentPageIndex: z.number().optional(),
+	paginationToken: z.string().optional()
+});
+function createPaginatedSchema(itemSchema) {
+	return z.object({
+		items: z.array(itemSchema),
+		pageInfo: PageInfoSchema
+	});
+}
+
+//#endregion
+//#region src/validation/common/regex_patterns.ts
+/**
+* Common regex patterns for validation
+*/
+/**
+* Decimal amount regex - allows up to 2 decimal places
+* Matches: "100", "100.00", "100.5", "0.99", etc.
+* Also allows empty string for optional fields
+*/
+const DECIMAL_AMOUNT_REGEX = /^((\d*\.?\d{1,2}|\d+)|)$/;
+/**
+* Decimal amount regex error message
+*/
+const DECIMAL_AMOUNT_ERROR_MESSAGE = "Must be a valid dollar amount with up to 2 decimal places or empty";
+/**
+* Decimal amount regex for 2 decimals or empty
+* Matches: "100.00", "0.99", "1234.56", etc. or empty string
+* Requires exactly 2 decimal places when not empty
+*/
+const DECIMAL_AMOUNT_2_DECIMALS_OR_EMPTY_REGEX = /^((\d*\.?\d{1,2}|\d+)|)$/;
+/**
+* Decimal amount regex for 2 decimals or empty error message
+*/
+const DECIMAL_AMOUNT_2_DECIMALS_OR_EMPTY_ERROR_MESSAGE = "Must be a valid dollar amount with up to 2 decimal places or empty";
+
+//#endregion
+//#region src/validation/user/user_enums_zod.ts
+const USER_TYPES = [
+	"consumer",
+	"lead",
+	"staff",
+	"super_admin"
+];
+const UserTypeEnum = z.enum([...USER_TYPES]);
+
+//#endregion
+//#region src/validation/user/user_create_zod.ts
+const createUserSchema = z.object({
+	email: z.string().trim().toLowerCase().min(3, "Please enter your email.").email("The email address is badly formatted."),
+	user_type: UserTypeEnum,
+	password: z.string().optional().nullable()
+});
+const createUserSchemaOutput = z.object({
+	id: z.string(),
+	email: z.string()
+});
+
+//#endregion
+//#region src/validation/credit_transaction/credit_balance_schema.ts
+const CreditBalanceSchema = z.object({
+	monthly: z.string(),
+	rollover: z.string()
+});
+const AddCreditsSchema = z.object({
+	amount: z.string().regex(DECIMAL_AMOUNT_REGEX, DECIMAL_AMOUNT_ERROR_MESSAGE),
+	reason: z.string().optional()
+});
+const SetMonthlyAllocationSchema = z.object({ amount: z.string().regex(DECIMAL_AMOUNT_REGEX, DECIMAL_AMOUNT_ERROR_MESSAGE) });
+const ResetMonthlyBalanceSchema = z.object({}).optional();
+
+//#endregion
+//#region src/validation/credit_transaction/credit_transaction_read_zod.ts
+/**
+* Transaction types for credit operations
+*/
+const CreditTransactionTypeEnum = z.enum([
+	"DEDUCTION",
+	"REFUND",
+	"PURCHASE_ONETIME",
+	"PURCHASE_RECURRING",
+	"ADJUSTMENT"
+]);
+/**
+* Schema for a credit transaction record
+*/
+const CreditTransactionReadSchema = z.object({
+	id: z.string(),
+	support_ticket_id: z.string().nullable().optional(),
+	amount: z.string(),
+	type: CreditTransactionTypeEnum,
+	description: z.string().nullable().optional(),
+	balance_after: z.string(),
+	created_at: z.string(),
+	created_by: z.string()
+});
+/**
+* Paginated schema for credit transactions
+*/
+const CreditTransactionPageSchema = createPaginatedSchema(CreditTransactionReadSchema);
+
+//#endregion
+//#region src/validation/credit_transaction/credit_transaction_filters_zod.ts
+/**
+* Filters for querying credit transactions
+* Supports operator-based filtering for advanced queries
+*
+* All filters support operators for advanced filtering:
+* - Enums: eq, ne, in, notIn
+* - Strings: eq, ne, contains, startsWith, endsWith
+* - Numbers: eq, ne, gt, gte, lt, lte, between
+* - Dates: eq, ne, gt, gte, lt, lte, between
+*
+* Examples:
+* - { type: { operator: "eq", value: "DEDUCTION" } }
+* - { amount: { operator: "gte", value: 100 } }
+* - { created_at: { operator: "gte", value: "2024-01-01" } }
+*/
+const CreditTransactionFiltersSchema = PaginationFiltersSchema.extend({
+	type: createEnumFilter(CreditTransactionTypeEnum).optional(),
+	support_ticket_id: StringFilterSchema.optional(),
+	amount: NumberFilterSchema.optional(),
+	balance_after: NumberFilterSchema.optional(),
+	created_at: DateFilterSchema.optional(),
+	created_by: StringFilterSchema.optional(),
+	search: z.object({
+		query: z.string(),
+		searchableFields: z.array(z.string())
+	}).optional()
+});
+
+//#endregion
+//#region src/validation/forgot_password_zod.ts
+const forgot_password_zod = z.object({ email: z.string().email().trim().toLowerCase() });
+
+//#endregion
+//#region src/types/record_types.ts
+/**
+* Record type constants and types for the application
+* These define all the different types of records that can exist in the system
+*/
+const RecordTypeValues = [
+	"attachment_folder",
+	"attachment",
+	"user",
+	"user_session",
+	"user_profile",
+	"refresh_token",
+	"refresh_token_family",
+	"user_subscription",
+	"password_reset",
+	"record_version",
+	"support_ticket",
+	"credit_transaction",
+	"team_member",
+	"client_contact",
+	"client_location",
+	"client_profile",
+	"business_profile",
+	"tracker",
+	"team",
+	"quote",
+	"note",
+	"followup"
+];
+const RecordConst = {
+	ATTACHMENT: "attachment",
+	ATTACHMENT_FOLDER: "attachment_folder",
+	USER: "user",
+	USER_SESSION: "user_session",
+	USER_PROFILE: "user_profile",
+	REFRESH_TOKEN: "refresh_token",
+	REFRESH_TOKEN_FAMILY: "refresh_token_family",
+	USER_SUBSCRIPTION: "user_subscription",
+	PASSWORD_RESET: "password_reset",
+	RECORD_VERSION: "record_version",
+	SUPPORT_TICKET: "support_ticket",
+	CREDIT_TRANSACTION: "credit_transaction",
+	TEAM_MEMBER: "team_member",
+	CLIENT_CONTACT: "client_contact",
+	CLIENT_LOCATION: "client_location",
+	CLIENT_PROFILE: "client_profile",
+	BUSINESS_PROFILE: "business_profile",
+	TRACKER: "tracker",
+	TEAM: "team",
+	NOTE: "note",
+	FOLLOWUP: "followup"
+};
+
+//#endregion
+//#region src/validation/note/note_read_zod.ts
+const RecordTypeEnum$3 = z.enum(RecordTypeValues);
+const NoteReadSchema = z.object({
+	id: z.string(),
+	record_id: z.string(),
+	record_type: RecordTypeEnum$3,
+	tag: z.string().optional().nullable(),
+	title: z.string().optional().nullable(),
+	body: z.string().optional().nullable(),
+	original_id: z.number().optional().nullable(),
+	is_internal: z.boolean(),
+	created_by: z.string(),
+	created_at: z.string(),
+	updated_by: z.string().optional().nullable(),
+	updated_at: z.string().optional().nullable(),
+	archived_by: z.string().optional().nullable(),
+	archived_at: z.string().optional().nullable(),
+	deleted_by: z.string().optional().nullable(),
+	deleted_at: z.string().optional().nullable()
+});
+
+//#endregion
+//#region src/validation/note/note_create_zod.ts
+const RecordTypeEnum$2 = z.enum(RecordTypeValues);
+const NoteCreateSchema = z.object({
+	record_id: z.string(),
+	record_type: RecordTypeEnum$2,
+	tag: z.string().optional().nullable(),
+	title: z.string().optional().nullable(),
+	body: z.string().optional().nullable(),
+	original_id: z.number().optional().nullable(),
+	is_internal: z.boolean().optional().default(false)
+});
+
+//#endregion
+//#region src/validation/note/note_update_zod.ts
+const RecordTypeEnum$1 = z.enum(RecordTypeValues);
+const NoteUpdateSchema = z.object({
+	id: z.string(),
+	record_id: z.string().optional(),
+	record_type: RecordTypeEnum$1.optional(),
+	tag: z.string().optional().nullable(),
+	title: z.string().optional().nullable(),
+	body: z.string().optional().nullable(),
+	original_id: z.number().optional().nullable(),
+	is_internal: z.boolean().optional()
+});
+
+//#endregion
+//#region src/validation/note/note_filters_zod.ts
+const RecordTypeFilterEnum = z.enum(RecordTypeValues);
+/**
+* Filters for note
+* Supports operator-based filtering for advanced queries
+*
+* All filters support operators for advanced filtering:
+* - Booleans: eq, ne
+* - Strings: eq, ne, contains, startsWith, endsWith
+* - Dates: eq, ne, gt, gte, lt, lte
+*
+* Examples:
+* - { record_type: { operator: "eq", value: "SUPPORT_TICKET" } }
+* - { title: { operator: "contains", value: "search" } }
+*/
+const NoteFiltersSchema = PaginationFiltersSchema.extend({
+	record_id: StringFilterSchema.optional(),
+	record_type: createEnumFilter(RecordTypeFilterEnum).optional(),
+	title: StringFilterSchema.optional(),
+	body: StringFilterSchema.optional(),
+	tag: StringFilterSchema.optional(),
+	created_at: DateFilterSchema.optional(),
+	updated_at: DateFilterSchema.optional(),
+	is_internal: BooleanFilterSchema.optional(),
+	search: z.object({
+		query: z.string(),
+		searchableFields: z.array(z.string())
+	}).optional()
+});
+const NoteFiltersSortDirectionEnum = z.enum(["asc", "desc"]);
+
+//#endregion
+//#region src/validation/record_version_zod.ts
+const RecordTypeEnum = z.enum(RecordTypeValues);
+const recordVersionSchema = z.object({
+	id: z.string(),
+	record_id: z.string(),
+	operation: z.string(),
+	recorded_at: z.string(),
+	record_type: z.string(),
+	record: z.string().optional().nullable(),
+	old_record: z.string().optional().nullable(),
+	auth_uid: z.string().optional().nullable(),
+	auth_role: z.string().optional().nullable(),
+	auth_username: z.string().optional().nullable()
+});
+const recordVersionPageSchema = z.object({
+	items: z.array(recordVersionSchema),
+	pageInfo: z.object({
+		hasNextPage: z.boolean(),
+		endCursor: z.string().optional().nullable()
+	})
+});
+const pageInfoSchema = z.object({
+	hasNextPage: z.boolean(),
+	endCursor: z.string().optional().nullable()
+});
+const recordVersionFiltersSchema = z.object({
+	start_date: z.string().optional().nullable(),
+	end_date: z.string().optional().nullable(),
+	limit: z.number().optional().nullable(),
+	cursor: z.string().optional().nullable()
+});
+const recordVersionFiltersInputSchema = z.object({
+	record_id: z.string(),
+	record_type: RecordTypeEnum,
+	filters: recordVersionFiltersSchema.optional().nullable()
+});
+/**
+* NEW: Breadcrumb-paginated record version response
+* Use this for new implementations
+*/
+const recordVersionPageBreadcrumbSchema = createPaginatedSchema(recordVersionSchema);
+/**
+* NEW: Filters with breadcrumb pagination support
+* Extends PaginationFiltersSchema for consistent pagination
+*/
+const recordVersionFiltersBreadcrumbSchema = z.object({
+	first: z.number().min(1).max(100).optional(),
+	after: z.string().optional(),
+	last: z.number().min(1).max(100).optional(),
+	before: z.string().optional(),
+	sortBy: z.string().optional(),
+	sortDirection: SortDirectionSchema.optional(),
+	paginationToken: z.string().optional(),
+	start_date: z.string().optional().nullable(),
+	end_date: z.string().optional().nullable()
+});
+const recordVersionFiltersInputBreadcrumbSchema = z.object({
+	record_id: z.string(),
+	record_type: RecordTypeEnum,
+	filters: recordVersionFiltersBreadcrumbSchema.optional().nullable()
+});
+
+//#endregion
+//#region src/validation/reset_password_zod.ts
+const resetPasswordInputSchema = z.object({ passwords: z.object({
+	password: z.string().min(8, { message: "Password must be at least 8 characters long" }).max(64, { message: "Password must not exceed 64 characters" }).refine((password) => !/^\s|\s$/.test(password), { message: "Password must not have leading or trailing whitespace" }).refine((password) => !isCommonPassword(password), { message: "Password is too common and easily guessed" }),
+	password_confirm: z.string().min(8)
+}).refine((data) => data.password === data.password_confirm, {
+	message: "Passwords do not match",
+	path: ["password_confirm"]
+}) });
+const resetPasswordSchema = resetPasswordInputSchema.extend({ token: z.string().min(20) });
+
+//#endregion
+//#region src/validation/signup_zod.ts
+const signupSchema = z.object({
+	email: z.string().trim().toLowerCase().min(3, "Please enter your email.").email("The email address is badly formatted."),
+	passwords: z.object({
+		password: passwordSchema,
+		password_confirm: z.string().min(1)
+	}).refine((data) => data.password === data.password_confirm, {
+		message: "Passwords do not match",
+		path: ["password_confirm"]
+	})
+});
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_shared/support_ticket_enums_zod.ts
+const SupportTicketTypeEnum = [
+	"IMPROVEMENT",
+	"BUG",
+	"FEATURE_REQUEST",
+	"OPERATIONAL"
+];
+const SupportTicketTypeSchema = z.enum(SupportTicketTypeEnum);
+const SupportTicketPriorityEnum = [
+	"LOW",
+	"MEDIUM",
+	"HIGH",
+	"CRITICAL"
+];
+/**
+* Enum for feature request priority levels
+*/
+const SupportTicketPrioritySchema = z.enum(SupportTicketPriorityEnum);
+/**
+* Enum for customer-facing support_ticket status (computed from approval_status + dev_lifecycle)
+* - PENDING: Awaiting admin review
+* - FOLLOWUP: Approved but not started
+* - IN_PROGRESS: Actively being worked on
+* - COMPLETED: Deployed to production
+* - CANCELLED: Rejected by admin
+*/
+const SupportTicketStatusEnum = [
+	"PENDING",
+	"FOLLOWUP",
+	"IN_PROGRESS",
+	"COMPLETED",
+	"CANCELLED"
+];
+const SupportTicketStatusSchema = z.enum(SupportTicketStatusEnum);
+/**
+* Enum for feature request approval status
+* - PENDING: Awaiting staff decision (customer-submitted)
+* - APPROVED: Approved by staff (with customer credits)
+* - REJECTED: Rejected by staff
+* - INTERNAL: Internal staff support_ticket (no approval/credits needed)
+*/
+const SupportTicketApprovalEnum = [
+	"PENDING",
+	"APPROVED",
+	"REJECTED",
+	"INTERNAL"
+];
+const SupportTicketApprovalSchema = z.enum(SupportTicketApprovalEnum);
+/**
+* Enum for internal development lifecycle stages
+* - BACKLOG: Approved but not started
+* - PLANNING: Scoping/design phase
+* - DEVELOPMENT: Actively coding
+* - CODE_REVIEW: In review
+* - TESTING: QA testing
+* - STAGING: On staging environment
+* - PO_APPROVAL: Waiting for PO/customer sign-off
+* - DEPLOYED: Live in production
+* - CANCELLED: Internal task cancelled (only for INTERNAL approval status)
+*/
+const SupportTicketDevLifecycleEnum = [
+	"PENDING",
+	"BACKLOG",
+	"PLANNING",
+	"DEVELOPMENT",
+	"CODE_REVIEW",
+	"TESTING",
+	"STAGING",
+	"PO_APPROVAL",
+	"DEPLOYED",
+	"CANCELLED"
+];
+const SupportTicketDevLifecycleSchema = z.enum(SupportTicketDevLifecycleEnum);
+/**
+* Dev lifecycle stages that can be manually set via update form
+* Excludes workflow-only stages:
+* - PENDING: Set by revert workflow
+* - DEPLOYED: Set by completeSupportTicket workflow
+* Staff can manually progress through: BACKLOG → PLANNING → DEVELOPMENT → CODE_REVIEW → TESTING → STAGING → PO_APPROVAL
+*/
+const SupportTicketDevLifecycleUpdateEnum = [
+	"BACKLOG",
+	"PLANNING",
+	"DEVELOPMENT",
+	"CODE_REVIEW",
+	"TESTING",
+	"STAGING",
+	"PO_APPROVAL"
+];
+const SupportTicketDevLifecycleUpdateSchema = z.enum(SupportTicketDevLifecycleUpdateEnum);
+/**
+* Filter-specific enum instances
+* These are separate Zod objects with the same values as above,
+* allowing GraphQL to generate distinct enum types for filters vs domain objects
+*/
+const SupportTicketTypeFilterSchema = z.enum(SupportTicketTypeEnum);
+const SupportTicketPriorityFilterSchema = z.enum(SupportTicketPriorityEnum);
+const SupportTicketStatusFilterSchema = z.enum(SupportTicketStatusEnum);
+const SupportTicketApprovalFilterSchema = z.enum(SupportTicketApprovalEnum);
+const SupportTicketDevLifecycleFilterSchema = z.enum(SupportTicketDevLifecycleEnum);
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_customer/customer_input_zod.ts
+/**
+* Schema for creating new support_ticket (customer)
+*/
+const CustomerSupportTicketCreateSchema = z.object({
+	title: z.string().min(5, "Please add a more descriptive title (at least 5 characters)").max(256, "Title is too long - keep it brief (under 256 characters)"),
+	description: z.string().optional().nullable(),
+	type: SupportTicketTypeSchema.default("FEATURE_REQUEST"),
+	priority: SupportTicketPrioritySchema.default("MEDIUM")
+});
+/**
+* Schema for updating support_ticket (customer - PENDING items only)
+*/
+const CustomerSupportTicketUpdateSchema = CustomerSupportTicketCreateSchema.extend({ id: z.string() });
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_customer/customer_read_zod.ts
+/**
+* Customer-specific read schema - ONLY includes fields customers can see
+* Excludes all staff-only fields like internalNotes, devLifecycle, timeline tracking, etc.
+*/
+const CustomerSupportTicketReadSchema = z.object({
+	id: z.string(),
+	display_id: z.string().optional().nullable(),
+	display_id_prefix: z.string().optional().nullable(),
+	title: z.string(),
+	description: z.string(),
+	type: SupportTicketTypeSchema,
+	priority: SupportTicketPrioritySchema,
+	status: SupportTicketStatusSchema,
+	is_locked: z.boolean(),
+	requester_name: z.string().optional().nullable(),
+	requester_email: z.string().email().optional().nullable(),
+	credit_value: z.string().optional().nullable(),
+	start_at: z.string().optional().nullable(),
+	target_at: z.string().optional().nullable(),
+	completed_at: z.string().optional().nullable(),
+	locked_approval_at: z.string().optional().nullable(),
+	created_by: z.string().optional().nullable(),
+	created_at: z.string().optional().nullable(),
+	updated_by: z.string().optional().nullable(),
+	updated_at: z.string().optional().nullable()
+});
+/**
+* Paginated customer support_ticket response
+*/
+const CustomerSupportTicketPageSchema = createPaginatedSchema(CustomerSupportTicketReadSchema);
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_customer/customer_support_ticket_filters_zod.ts
+/**
+* Customer-facing filters for support_ticket
+* Includes all fields customers can see and filter on
+*
+* - Cannot filter by internal fields (isInternalOnly, approvalStatus, devLifecycle)
+* - Can filter on all visible fields including credits, requester info, etc.
+*/
+const CustomerSupportTicketFiltersSchema = PaginationFiltersSchema.extend({
+	type: createEnumFilter(SupportTicketTypeFilterSchema).optional(),
+	status: createEnumFilter(SupportTicketStatusFilterSchema).optional(),
+	priority: createEnumFilter(SupportTicketPriorityFilterSchema).optional(),
+	title: StringFilterSchema.optional(),
+	description: StringFilterSchema.optional(),
+	requester_name: StringFilterSchema.optional(),
+	requester_email: StringFilterSchema.optional(),
+	is_locked: BooleanFilterSchema.optional(),
+	credit_value: NumberFilterSchema.optional(),
+	created_at: DateFilterSchema.optional(),
+	updated_at: DateFilterSchema.optional(),
+	start_at: DateFilterSchema.optional(),
+	target_at: DateFilterSchema.optional(),
+	completed_at: DateFilterSchema.optional(),
+	search: z.object({
+		query: z.string(),
+		searchableFields: z.array(z.string())
+	}).optional()
+});
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_staff/staff_read_zod.ts
+/**
+* Staff-specific read schema - includes ALL fields including staff-only data
+* This is what staff see when they query support_ticket (includes internal notes, dev lifecycle, etc.)
+*/
+const StaffSupportTicketReadSchema = z.object({
+	id: z.string(),
+	display_id: z.string().optional().nullable(),
+	display_id_prefix: z.string().optional().nullable(),
+	title: z.string(),
+	description: z.string(),
+	type: SupportTicketTypeSchema,
+	priority: SupportTicketPrioritySchema,
+	status: SupportTicketStatusSchema,
+	approval_status: SupportTicketApprovalSchema,
+	is_locked: z.boolean(),
+	can_delete: z.boolean(),
+	requester_name: z.string().optional().nullable(),
+	requester_email: z.string().email().optional().nullable(),
+	dev_lifecycle: SupportTicketDevLifecycleSchema.optional().nullable(),
+	credit_value: z.string().optional().nullable(),
+	delivered_value: z.string().optional().nullable(),
+	start_at: z.string().optional().nullable(),
+	target_at: z.string().optional().nullable(),
+	completed_at: z.string().optional().nullable(),
+	locked_approval_at: z.string().optional().nullable(),
+	created_by: z.string().optional().nullable(),
+	created_at: z.string().optional().nullable(),
+	updated_by: z.string().optional().nullable(),
+	updated_at: z.string().optional().nullable()
+});
+/**
+* Paginated staff support_ticket response
+*/
+const StaffSupportTicketPageSchema = createPaginatedSchema(StaffSupportTicketReadSchema);
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_staff/staff_support_ticket_filters_zod.ts
+/**
+* Staff/Admin filters for support_ticket
+* Full access to all filtering capabilities including internal fields
+*
+* All filters support operators for advanced filtering:
+* - Enums: eq, ne
+* - Booleans: eq, ne
+* - Strings: eq, ne, contains, startsWith, endsWith
+* - Numbers: eq, ne, gt, gte, lt, lte
+* - Dates: eq, ne, gt, gte, lt, lte
+*
+* Examples:
+* - { type: { operator: "eq", value: "BUG" } }
+* - { approvalStatus: { operator: "eq", value: "INTERNAL" } } // Filter for internal tasks
+* - { title: { operator: "contains", value: "search" } }
+* - { creditValue: { operator: "gte", value: 100 } }
+* - { createdAt: { operator: "gte", value: "2024-01-01" } }
+*/
+const StaffSupportTicketFiltersSchema = PaginationFiltersSchema.extend({
+	type: createEnumFilter(SupportTicketTypeFilterSchema).optional(),
+	status: createEnumFilter(SupportTicketStatusFilterSchema).optional(),
+	approval_status: createEnumFilter(SupportTicketApprovalFilterSchema).optional(),
+	priority: createEnumFilter(SupportTicketPriorityFilterSchema).optional(),
+	dev_lifecycle: createEnumFilter(SupportTicketDevLifecycleFilterSchema).optional(),
+	title: StringFilterSchema.optional(),
+	description: StringFilterSchema.optional(),
+	requester_name: StringFilterSchema.optional(),
+	requester_email: StringFilterSchema.optional(),
+	is_locked: BooleanFilterSchema.optional(),
+	credit_value: NumberFilterSchema.optional(),
+	delivered_value: NumberFilterSchema.optional(),
+	created_at: DateFilterSchema.optional(),
+	updated_at: DateFilterSchema.optional(),
+	start_at: DateFilterSchema.optional(),
+	target_at: DateFilterSchema.optional(),
+	completed_at: DateFilterSchema.optional(),
+	search: z.object({
+		query: z.string(),
+		searchableFields: z.array(z.string())
+	}).optional()
+});
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_staff/staff_update_zod.ts
+/**
+* Base schema for staff support_ticket updates (general editing)
+*
+* Workflow-specific fields NOT included here:
+* - approvalStatus: Use approve/reject/revert workflows, or set to INTERNAL at creation
+*
+* Note: completeSupportTicket workflow sets deliveredValue + completedAt initially,
+* but they can be adjusted here afterwards for corrections.
+*
+* Business rules validated in backend:
+* - Can't edit creditValue unless PENDING (INTERNAL support_ticket can't have credits)
+* - Can't edit devLifecycle unless APPROVED or INTERNAL
+* - Can't edit deliveredValue unless DEPLOYED
+* - Can't edit completedAt unless DEPLOYED
+* - etc.
+*/
+const StaffSupportTicketInputBaseSchema = z.object({
+	title: z.string().min(5, "Please add a more descriptive title (at least 5 characters)").max(256, "Title is too long - keep it brief (under 256 characters)"),
+	description: z.string().optional().nullable(),
+	type: SupportTicketTypeSchema,
+	priority: SupportTicketPrioritySchema,
+	dev_lifecycle: SupportTicketDevLifecycleUpdateSchema.optional(),
+	credit_value: z.string().regex(DECIMAL_AMOUNT_REGEX, DECIMAL_AMOUNT_ERROR_MESSAGE).optional().nullable(),
+	delivered_value: z.string().regex(DECIMAL_AMOUNT_2_DECIMALS_OR_EMPTY_REGEX, DECIMAL_AMOUNT_2_DECIMALS_OR_EMPTY_ERROR_MESSAGE).optional().nullable(),
+	start_at: z.string().regex(/\d{4}-\d{2}-\d{2}/, "Date must be in the format YYYY-MM-DD").optional().nullable(),
+	target_at: z.string().regex(/\d{4}-\d{2}-\d{2}/, "Date must be in the format YYYY-MM-DD").optional().nullable(),
+	completed_at: z.string().regex(/\d{4}-\d{2}-\d{2}/, "Date must be in the format YYYY-MM-DD").optional().nullable()
+});
+const StaffSupportTicketCreateSchema = StaffSupportTicketInputBaseSchema.extend({ is_internal: z.boolean().optional() });
+const StaffSupportTicketUpdateSchema = StaffSupportTicketInputBaseSchema.extend({ id: z.string() });
+const StaffSupportTicketInputSchema = StaffSupportTicketUpdateSchema;
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_staff/staff_workflow_zod.ts
+/**
+* Staff workflow schemas
+* These are for critical state transitions in the support_ticket lifecycle
+*/
+/**
+* Approve support_ticket (PENDING → APPROVED)
+* Deducts credits and sets dev_lifecycle to BACKLOG
+*/
+const ApproveSupportTicketSchema = z.object({ id: z.string() });
+/**
+* Reject support_ticket (PENDING → REJECTED)
+* Locks the support_ticket without deducting credits
+*/
+const RejectSupportTicketSchema = z.object({ id: z.string() });
+/**
+* Revert support_ticket (APPROVED/REJECTED → PENDING)
+* Refunds credits if applicable and unlocks the support_ticket
+*/
+const RevertSupportTicketSchema = z.object({ id: z.string() });
+/**
+* Complete support_ticket (devLifecycle → DEPLOYED)
+* Marks support_ticket as deployed and captures actual delivered value
+* Auto-sets completedAt timestamp
+*/
+const CompleteSupportTicketSchema = z.object({
+	id: z.string(),
+	delivered_value: z.string().regex(/^(\d*\.?\d{1,2}|\d+)$/, "Must be a valid dollar amount with up to 2 decimal places")
+});
+/**
+* Delete support_ticket (soft delete)
+* Cannot delete APPROVED tickets (charged to customer)
+* Can delete PENDING, REJECTED, INTERNAL tickets
+*/
+const DeleteSupportTicketSchema = z.object({ id: z.string() });
+/**
+* Cancel internal task (devLifecycle → CANCELLED)
+* Only for INTERNAL approval_status tickets
+* Customer tickets use reject workflow instead
+*/
+const CancelInternalTaskSchema = z.object({ id: z.string() });
+/**
+* Reactivate terminal internal task (CANCELLED or DEPLOYED → BACKLOG)
+* Only for INTERNAL approval_status tickets with dev_lifecycle = CANCELLED or DEPLOYED
+* Clears completed_at timestamp and reopens task for more work
+*/
+const ReactivateInternalTaskSchema = z.object({ id: z.string() });
+
+//#endregion
+//#region src/validation/support_ticket/support_ticket_enrichment.ts
+/**
+* Schema for support ticket record data in enriched contexts
+* This defines the minimal fields needed for display/enrichment
+* Includes id for mapping purposes, even though it's also in record_id
+*/
+const SupportTicketRecordDataSchema = z.object({
+	id: z.string(),
+	display_id: z.string().optional().nullable(),
+	title: z.string()
+});
+
+//#endregion
+//#region src/validation/team/team_enums_zod.ts
+const TeamStatusSchema = z.enum(["active", "inactive"]).describe("TeamStatus");
+
+//#endregion
+//#region src/validation/team/team_filters_zod.ts
+/**
+* Filters for teams
+*
+* All filters support operators for advanced filtering:
+* - Booleans: eq, ne
+* - Strings: eq, ne, contains, startsWith, endsWith
+* - Dates: eq, ne, gt, gte, lt, lte
+*
+* Examples:
+* - { display_name: { operator: "contains", value: "search" } }
+* - { contact_email: { operator: "eq", value: "test@example.com" } }
+* - { created_at: { operator: "gte", value: "2024-01-01" } }
+*/
+const TeamFiltersSchema = PaginationFiltersSchema.extend({
+	unique_name: StringFilterSchema.optional(),
+	display_name: StringFilterSchema.optional(),
+	legal_name: StringFilterSchema.optional(),
+	contact_email: StringFilterSchema.optional(),
+	address_city: StringFilterSchema.optional(),
+	address_zip: StringFilterSchema.optional(),
+	includeArchived: BooleanFilterSchema.optional(),
+	created_at: DateFilterSchema.optional(),
+	updated_at: DateFilterSchema.optional(),
+	archived_at: DateFilterSchema.optional(),
+	search: z.object({
+		query: z.string(),
+		searchableFields: z.array(z.string())
+	}).optional()
+});
+
+//#endregion
+//#region src/validation/team/team_input_zod.ts
+const TeamInputBaseSchema = z.object({
+	unique_name: z.string().min(3, "Unique name must be between 3 and 64 characters").max(64).optional().nullable(),
+	display_name: z.string().min(3, "Display name must be between 3 and 64 characters").max(64),
+	legal_name: z.string().optional().nullable(),
+	description: z.string().optional().nullable(),
+	contact_name: z.string().optional().nullable(),
+	contact_email: z.string().email().optional().nullable(),
+	contact_business_phone: z.string().optional().nullable(),
+	contact_mobile_phone: z.string().optional().nullable(),
+	contact_time_zone: z.string().optional().nullable(),
+	address_full: z.string().optional().nullable(),
+	address_city: z.string().optional().nullable(),
+	address_zip: z.string().optional().nullable(),
+	twitter_username: z.string().optional().nullable(),
+	url: z.string().url().optional().nullable(),
+	logo: z.string().optional().nullable(),
+	email_sent_from: z.string().email().optional().nullable(),
+	email_reply_to: z.string().email().optional().nullable()
+});
+const TeamCreateSchema = TeamInputBaseSchema;
+const TeamUpdateSchema = TeamInputBaseSchema.extend({ id: z.string() });
+
+//#endregion
+//#region src/validation/team/team_read_zod.ts
+const TeamReadSchema = TeamCreateSchema.extend({
+	id: z.string(),
+	original_id: z.string().optional().nullable(),
+	path: z.string().optional().nullable(),
+	created_at: z.string(),
+	updated_at: z.string().optional().nullable(),
+	created_by: z.string(),
+	updated_by: z.string().optional().nullable(),
+	archived_at: z.string().optional().nullable(),
+	archived_by: z.string().optional().nullable()
+});
+
+//#endregion
+//#region src/validation/team/team_page_zod.ts
+const TeamPageSchema = createPaginatedSchema(TeamReadSchema);
+
+//#endregion
+//#region src/validation/team/team_user_teams_zod.ts
+/**
+* Schema for a team option in user teams list
+* Includes all team fields to match the GraphQL query
+*/
+const TeamOptionSchema = TeamReadSchema;
+/**
+* Schema for the list of teams that a user is part of
+*/
+const UserTeamsSchema = z.object({ items: z.array(TeamOptionSchema) });
+
+//#endregion
+//#region src/validation/team_member/team_member_enums_zod.ts
+/**
+* Team Member Role Enum
+* - owner: Full permissions (create, read, update, delete)
+* - manager: Can create and read (cannot update or delete)
+* - member: Can create and read (cannot update or delete)
+* - client: Client role (permissions TBD)
+*/
+const TeamMemberRoleEnum = [
+	"owner",
+	"manager",
+	"member",
+	"client"
+];
+const TeamMemberRoleSchema = z.enum(TeamMemberRoleEnum);
+/**
+* Filter-specific enum instance
+* This is a separate Zod object with the same values as above,
+* allowing GraphQL to generate distinct enum types for filters vs domain objects
+*/
+const TeamMemberRoleFilterSchema = z.enum(TeamMemberRoleEnum);
+
+//#endregion
+//#region src/validation/team_member/team_member_filters_zod.ts
+/**
+* Filters for team_member
+* Supports operator-based filtering for advanced queries
+*
+* All filters support operators for advanced filtering:
+* - Numbers: eq, ne, gt, gte, lt, lte
+* - Strings: eq, ne, contains, startsWith, endsWith
+* - Dates: eq, ne, gt, gte, lt, lte
+*
+* Examples:
+* - { original_id: { operator: "eq", value: 123 } }
+* - { team_id: { operator: "eq", value: "team_123" } }
+* - { display_name: { operator: "contains", value: "John" } }
+* - { created_at: { operator: "gte", value: "2024-01-01" } }
+*/
+const TeamMemberFiltersSchema = PaginationFiltersSchema.extend({
+	original_id: NumberFilterSchema.optional(),
+	team_id: StringFilterSchema.optional(),
+	original_team_id: StringFilterSchema.optional(),
+	user_id: StringFilterSchema.optional(),
+	original_user_id: StringFilterSchema.optional(),
+	role: createEnumFilter(TeamMemberRoleFilterSchema).optional(),
+	display_name: StringFilterSchema.optional(),
+	business_phone: StringFilterSchema.optional(),
+	mobile_phone: StringFilterSchema.optional(),
+	email_address: StringFilterSchema.optional(),
+	website_address: StringFilterSchema.optional(),
+	time_zone: StringFilterSchema.optional(),
+	created_at: DateFilterSchema.optional(),
+	updated_at: DateFilterSchema.optional(),
+	deleted_at: DateFilterSchema.optional(),
+	search: z.object({
+		query: z.string(),
+		searchableFields: z.array(z.string())
+	}).optional()
+});
+
+//#endregion
+//#region src/validation/team_member/team_member_input_zod.ts
+const TeamMemberBaseSchema = z.object({
+	team_id: z.string(),
+	user_id: z.string(),
+	role: TeamMemberRoleSchema,
+	display_name: z.string().min(3, "Display name must be at least 3 characters").max(64, "Display name must be at most 64 characters"),
+	business_phone: z.string().optional().nullable(),
+	mobile_phone: z.string().optional().nullable(),
+	email_address: z.string().email(),
+	website_address: z.string().url().optional().nullable(),
+	time_zone: z.string().optional().nullable()
+});
+const TeamMemberCreateSchema = TeamMemberBaseSchema;
+const TeamMemberUpdateSchema = TeamMemberBaseSchema.extend({ id: z.string() });
+
+//#endregion
+//#region src/validation/team_member/team_member_read_zod.ts
+const TeamMemberReadSchema = z.object({
+	id: z.string(),
+	original_id: z.number().optional().nullable(),
+	team_id: z.string(),
+	original_team_id: z.string().optional().nullable(),
+	user_id: z.string(),
+	original_user_id: z.string().optional().nullable(),
+	role: TeamMemberRoleSchema,
+	display_name: z.string().optional().nullable(),
+	business_phone: z.string().optional().nullable(),
+	mobile_phone: z.string().optional().nullable(),
+	email_address: z.string().email(),
+	website_address: z.string().optional().nullable(),
+	time_zone: z.string().optional().nullable(),
+	created_at: z.string(),
+	created_by: z.string(),
+	updated_at: z.string().optional().nullable(),
+	updated_by: z.string().optional().nullable(),
+	deleted_at: z.string().optional().nullable(),
+	deleted_by: z.string().optional().nullable()
+});
+
+//#endregion
+//#region src/validation/team_member/team_member_user_team_members_zod.ts
+/**
+* Schema for a team member option in user team members list
+* Includes all team member fields to match the query
+*/
+const TeamMemberOptionSchema = TeamMemberReadSchema;
+/**
+* Schema for the list of team members that a user can see (from their teams)
+*/
+const UserTeamMembersSchema = z.object({ items: z.array(TeamMemberOptionSchema) });
+
+//#endregion
+//#region src/validation/user/user_read_zod.ts
+const UserReadSchema = z.object({
+	id: z.string(),
+	username: z.string(),
+	email: z.string(),
+	email_verified: z.boolean(),
+	user_type: UserTypeEnum,
+	created_at: z.string(),
+	updated_at: z.string().nullable()
+});
+
+//#endregion
+//#region src/validation/user/user_update_zod.ts
+const UserUpdateSchema = z.object({
+	id: z.string(),
+	user_type: UserTypeEnum
+});
+
+//#endregion
+//#region src/validation/user_profile_zod.ts
+/**
+* Base schema for user profile
+*/
+const UserProfileBaseSchema = z.object({
+	first_name: z.string().max(255, "First name is too long").nullable().optional(),
+	last_name: z.string().max(255, "Last name is too long").nullable().optional(),
+	bio: z.string().max(1e3, "Bio is too long").nullable().optional()
+});
+/**
+* Schema for updating a user profile
+*/
+const UserProfileUpdateSchema = UserProfileBaseSchema.extend({ user_id: z.string().min(1, "User ID is required") });
+/**
+* Schema for reading a user profile
+*/
+const UserProfileReadSchema = UserProfileBaseSchema.extend({
+	id: z.string().min(1, "ID is required"),
+	user_id: z.string().min(1, "User ID is required"),
+	created_at: z.string().datetime(),
+	created_by: z.string().min(1, "Created by is required"),
+	updated_at: z.string().datetime().nullable(),
+	updated_by: z.string().nullable()
+});
+
+//#endregion
+//#region src/validation/user_session_zod.ts
+const userSessionSchema = z.object({
+	created_at: z.string(),
+	expires_at: z.string(),
+	status: z.string(),
+	user_agent: z.string().optional().nullable(),
+	ip_address: z.string().optional().nullable(),
+	user: z.object({
+		userId: z.string(),
+		email: z.string(),
+		username: z.string(),
+		email_verified: z.boolean(),
+		user_type: z.string(),
+		first_name: z.string().optional().nullable(),
+		last_name: z.string().optional().nullable(),
+		avatar_url: z.string().optional().nullable(),
+		subscriptions: z.array(z.object({
+			subscription_id: z.string(),
+			subscription_status: z.string().optional().nullable(),
+			subscription_created: z.string(),
+			subscription_current_period_start: z.string(),
+			subscription_current_period_end: z.string(),
+			subscription_cancel_at: z.string().optional().nullable(),
+			subscription_canceled_at: z.string().optional().nullable(),
+			product_name: z.string().optional().nullable(),
+			price_amount: z.number().nullable(),
+			price_currency: z.string().optional().nullable()
+		})).optional().nullable()
+	})
+});
+const loginResponseSchema = z.object({
+	frontend_session: userSessionSchema,
+	access_token: z.string(),
+	refresh_token: z.string(),
+	user_details_token: z.string()
+});
+
+//#endregion
+//#region src/utils/enum_labels.ts
+/**
+* Utility functions for converting enum values to human-readable display labels
+*/
+/**
+* Normalizes and validates input
+*/
+function normalizeInput(value) {
+	if (typeof value !== "string") return String(value);
+	return value.trim().toLowerCase();
+}
+/**
+* Converts a snake_case string to Title Case
+* Handles edge cases like empty strings, single characters, numbers, etc.
+*
+* Examples:
+* - "order_signed" -> "Order Signed"
+* - "active_mtm" -> "Active Mtm"
+* - "create_a_quote" -> "Create A Quote"
+*/
+function snakeCaseToTitleCase(value) {
+	const normalized = normalizeInput(value);
+	if (!normalized) return value;
+	const parts = normalized.split("_").filter((part) => part.length > 0);
+	if (parts.length === 0) return value;
+	return parts.map((part) => {
+		if (part.length === 0) return part;
+		return part.charAt(0).toUpperCase() + part.slice(1);
+	}).join(" ");
+}
+/**
+* Determines if a value should use dash formatting based on structure
+* Uses heuristics: length of first part, total parts, etc.
+*/
+function shouldUseDashes(parts) {
+	if (parts.length < 2) return false;
+	const firstPart = parts[0];
+	if (!firstPart) return false;
+	if (firstPart.length <= 2) return true;
+	if (firstPart.length >= 3 && firstPart.length <= 8 && parts.length >= 2) return true;
+	if (parts.length >= 3) return true;
+	return parts.length >= 2;
+}
+/**
+* Formats a value with dashes - intelligently splits based on structure
+*
+* Examples:
+* - "order_signed" -> "Order - Signed"
+* - "closed_lost" -> "Closed - Lost"
+* - "active_in_term" -> "Active - In Term"
+* - "on_hold_broker" -> "On Hold - Broker"
+*/
+function formatWithDashes(value) {
+	const parts = normalizeInput(value).split("_").filter((part) => part.length > 0);
+	if (parts.length < 2) return snakeCaseToTitleCase(value);
+	const firstPart = parts[0];
+	const secondPart = parts[1];
+	if (!firstPart) return snakeCaseToTitleCase(value);
+	if (parts.length === 2) {
+		if (!secondPart) return snakeCaseToTitleCase(value);
+		return `${snakeCaseToTitleCase(firstPart)} - ${snakeCaseToTitleCase(secondPart)}`;
+	}
+	if (firstPart.length <= 3) return `${snakeCaseToTitleCase(firstPart)} - ${snakeCaseToTitleCase(parts.slice(1).join("_"))}`;
+	if (secondPart && firstPart.length > secondPart.length) return `${snakeCaseToTitleCase(firstPart)} - ${snakeCaseToTitleCase(parts.slice(1).join("_"))}`;
+	else return `${snakeCaseToTitleCase(parts.slice(0, 2).join("_"))} - ${snakeCaseToTitleCase(parts.slice(2).join("_"))}`;
+}
+/**
+* Converts an enum value to a display label
+* Uses intelligent formatting based on structure
+*
+* @param value - The enum value in snake_case (or any case)
+* @param customOverrides - Optional map of custom overrides for specific values
+* @returns The formatted display label
+*/
+function enumToDisplayLabel(value, customOverrides) {
+	if (!value || typeof value !== "string") return String(value || "");
+	const normalized = normalizeInput(value);
+	if (customOverrides) {
+		if (customOverrides[value]) return customOverrides[value];
+		if (customOverrides[normalized]) return customOverrides[normalized];
+	}
+	const parts = normalized.split("_").filter((part) => part.length > 0);
+	if (parts.length === 0) return value;
+	if (shouldUseDashes(parts)) return formatWithDashes(value);
+	return snakeCaseToTitleCase(value);
+}
+/**
+* Creates a label map for an array of enum values
+*
+* @param enumValues - Array of enum values
+* @param customOverrides - Optional map of custom overrides for specific values
+* @returns Record mapping enum values to display labels
+*/
+function createEnumLabelMap(enumValues, customOverrides) {
+	const labelMap = {};
+	for (const value of enumValues) labelMap[value] = enumToDisplayLabel(value, customOverrides);
+	return labelMap;
+}
+/**
+* Converts an enum label map to select options for dropdowns
+*
+* @param labelMap - Record mapping enum values to display labels
+* @returns Array of select options
+*/
+function createSelectOptionsFromLabelMap(labelMap) {
+	return Object.entries(labelMap).map(([value, label]) => ({
+		value,
+		label
+	}));
+}
+
+//#endregion
+//#region src/utils/file.ts
+/**
+* File utility functions for sanitizing and processing file names.
+*/
+/**
+* Sanitizes a file name by replacing non-alphanumeric characters with underscores.
+* Provides several improvements over basic sanitization:
+* - Converts dashes to underscores first (to avoid mixed dash/underscore patterns)
+* - Collapses multiple consecutive underscores
+* - Trims leading/trailing underscores
+* - Handles files without extensions properly
+* - Sanitizes the extension too
+* - Enforces 800-byte limit for R2 compatibility
+* - Provides fallback for completely invalid names
+*
+* This function enforces an 800-byte limit to comply with Cloudflare R2's 1,024 byte
+* object key limit (leaving room for path overhead).
+*
+* @param fileName - The original file name to sanitize
+* @returns The sanitized file name with underscores replacing non-alphanumeric characters
+*
+* @example
+* ```typescript
+* sanitizeFileName('Sun Life Sheet 2021-10-13.xls')
+* // Returns: 'Sun_Life_Sheet_2021_10_13.xls'
+*
+* sanitizeFileName('my-file@2023.pdf')
+* // Returns: 'my_file_2023.pdf'
+*
+* sanitizeFileName('document.txt')
+* // Returns: 'document.txt'
+*
+* sanitizeFileName('file---name.txt')
+* // Returns: 'file_name.txt' (collapsed underscores)
+*
+* sanitizeFileName('file-name_test.txt')
+* // Returns: 'file_name_test.txt' (dashes converted first, no mixed patterns)
+*
+* sanitizeFileName('!!!file.txt')
+* // Returns: 'file.txt' (trimmed underscores)
+*
+* sanitizeFileName('')
+* // Returns: 'unnamed_file' (fallback)
+* ```
+*/
+function sanitizeFileName(fileName) {
+	if (!fileName || fileName.trim() === "") return "unnamed_file";
+	const lastDotIndex = fileName.lastIndexOf(".");
+	const hasExtension = lastDotIndex > 0;
+	let name = hasExtension ? fileName.substring(0, lastDotIndex) : fileName;
+	let extension = hasExtension ? fileName.substring(lastDotIndex + 1) : "";
+	const sanitize = (str) => str.replace(/-/g, "_").replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+	name = sanitize(name);
+	extension = sanitize(extension);
+	if (!name) name = "file";
+	const sanitized = extension ? `${name}.${extension}` : name;
+	const encoder = new TextEncoder();
+	if (encoder.encode(sanitized).length > 800) {
+		const maxNameBytes = 800 - (extension ? encoder.encode(`.${extension}`).length : 0);
+		let truncatedName = "";
+		let currentBytes = 0;
+		for (const char of name) {
+			const charBytes = encoder.encode(char).length;
+			if (currentBytes + charBytes > maxNameBytes) break;
+			truncatedName += char;
+			currentBytes += charBytes;
+		}
+		return extension ? `${truncatedName}.${extension}` : truncatedName;
+	}
+	return sanitized;
+}
+
+//#endregion
+//#region src/utils/money.ts
+/**
+* Money calculation utilities using strings for storage and numbers for calculations.
+* All monetary values are stored as strings.
+*/
+/**
+* Adds two or more monetary values
+* @param values Monetary values as strings
+* @returns Sum as string
+*/
+const addMoney = (...values) => values.reduce((sum, value) => sum + Number(value), 0).toString();
+/**
+* Subtracts monetary values from the first value
+* @param minuend Value to subtract from
+* @param subtrahends Values to subtract
+* @returns Difference as string
+*/
+const subtractMoney = (minuend, ...subtrahends) => subtrahends.reduce((diff, value) => diff - Number(value), Number(minuend)).toString();
+/**
+* Multiplies a monetary value by a number
+* @param amount Amount as string
+* @param multiplier Number to multiply by
+* @returns Product as string
+*/
+const multiplyMoney = (amount, multiplier) => (Number(amount) * multiplier).toString();
+/**
+* Divides a monetary value by a number
+* @param amount Amount as string
+* @param divisor Number to divide by
+* @returns Quotient as string
+*/
+const divideMoney = (amount, divisor) => (Number(amount) / divisor).toString();
+/**
+* Applies a percentage to a monetary value
+* @param amount Amount as string
+* @param percentage Percentage as decimal (e.g., 0.15 for 15%)
+* @returns Result as string
+*/
+const applyPercentage = (amount, percentage) => multiplyMoney(amount, 1 + percentage);
+/**
+* Rounds a monetary value
+* @param amount Amount to round
+* @returns Rounded amount as string
+*/
+const roundMoney = (amount) => (Math.round(Number(amount) * 100) / 100).toString();
+/**
+* Formats a number as currency
+* @param value Number to format
+* @returns Formatted currency string
+*/
+const formatCurrency = (value) => {
+	return new Intl.NumberFormat("en-US", {
+		style: "currency",
+		currency: "USD"
+	}).format(value);
+};
+/**
+* Formats a dollar amount as currency
+* @param amount Amount as string
+* @returns Formatted currency string
+*/
+const formatDollar = (amount) => {
+	if (amount === null || amount === void 0) return "$0.00";
+	return new Intl.NumberFormat("en-US", {
+		style: "currency",
+		currency: "USD"
+	}).format(Number(amount));
+};
+
+//#endregion
+export { AddCreditsSchema, ApproveSupportTicketSchema, AttachmentCreateSchema, AttachmentFiltersSchema, AttachmentFiltersSchema as attachmentFilters_zod, AttachmentFolderCreateSchema, AttachmentFolderReadSchema, AttachmentFolderUpdateSchema, AttachmentPageSchema, AttachmentPageSchema as attachmentPage_zod, AttachmentReadSchema, AttachmentReadSchema as attachment_zod, AttachmentUpdateSchema, BaseFilterSchema, BooleanFilterSchema, CancelInternalTaskSchema, CompleteSupportTicketSchema, CreditBalanceSchema, CreditTransactionFiltersSchema, CreditTransactionPageSchema, CreditTransactionReadSchema, CreditTransactionTypeEnum, CustomerSupportTicketCreateSchema, CustomerSupportTicketFiltersSchema, CustomerSupportTicketPageSchema, CustomerSupportTicketReadSchema, CustomerSupportTicketUpdateSchema, DECIMAL_AMOUNT_2_DECIMALS_OR_EMPTY_ERROR_MESSAGE, DECIMAL_AMOUNT_2_DECIMALS_OR_EMPTY_REGEX, DECIMAL_AMOUNT_ERROR_MESSAGE, DECIMAL_AMOUNT_REGEX, DataTypeSchema, DateFilterSchema, DateOperatorSchema, DeleteSupportTicketSchema, EmailEntrySchema, EqualityArrayOperatorSchema, EqualityOperatorSchema, FilterConfigSchema, NoteCreateSchema, NoteFiltersSchema, NoteFiltersSortDirectionEnum, NoteReadSchema, NoteUpdateSchema, NumberFilterSchema, NumberOperatorSchema, OPERATORS, PageInfoSchema, PaginationFiltersSchema, ReactivateInternalTaskSchema, ReadNotificationEmailsSchema, RecordConst, RecordTypeValues, RejectSupportTicketSchema, ResetMonthlyBalanceSchema, RevertSupportTicketSchema, SetMonthlyAllocationSchema, SortDirectionSchema, StaffSupportTicketCreateSchema, StaffSupportTicketFiltersSchema, StaffSupportTicketInputSchema, StaffSupportTicketPageSchema, StaffSupportTicketReadSchema, StaffSupportTicketUpdateSchema, StringFilterSchema, StringOperatorSchema, SupportTicketApprovalEnum, SupportTicketApprovalFilterSchema, SupportTicketApprovalSchema, SupportTicketDevLifecycleEnum, SupportTicketDevLifecycleFilterSchema, SupportTicketDevLifecycleSchema, SupportTicketDevLifecycleUpdateEnum, SupportTicketDevLifecycleUpdateSchema, SupportTicketPriorityEnum, SupportTicketPriorityFilterSchema, SupportTicketPrioritySchema, SupportTicketRecordDataSchema, SupportTicketStatusEnum, SupportTicketStatusFilterSchema, SupportTicketStatusSchema, SupportTicketTypeEnum, SupportTicketTypeFilterSchema, SupportTicketTypeSchema, TeamCreateSchema, TeamFiltersSchema, TeamInputBaseSchema, TeamMemberCreateSchema, TeamMemberFiltersSchema, TeamMemberOptionSchema, TeamMemberReadSchema, TeamMemberRoleEnum, TeamMemberRoleFilterSchema, TeamMemberRoleSchema, TeamMemberUpdateSchema, TeamOptionSchema, TeamPageSchema, TeamReadSchema, TeamStatusSchema, TeamUpdateSchema, USER_TYPES, UpdateNotificationEmailsSchema, UserProfileBaseSchema, UserProfileReadSchema, UserProfileUpdateSchema, UserReadSchema, UserTeamMembersSchema, UserTeamsSchema, UserTypeEnum, UserUpdateSchema, addMoney, applyPercentage, changePasswordSchema, createEnumFilter, createEnumLabelMap, createNewEmailEntry, createPaginatedSchema, createSelectOptionsFromLabelMap, createUserSchema, createUserSchemaOutput, divideMoney, enumToDisplayLabel, forgot_password_zod, formatCurrency, formatDollar, isCommonPassword, loginResponseSchema, loginSchema, multiplyMoney, pageInfoSchema, passwordSchema, recordVersionFiltersBreadcrumbSchema, recordVersionFiltersInputBreadcrumbSchema, recordVersionFiltersInputSchema, recordVersionFiltersSchema, recordVersionPageBreadcrumbSchema, recordVersionPageSchema, recordVersionSchema, resetPasswordInputSchema, resetPasswordSchema, roundMoney, sanitizeFileName, signupSchema, subtractMoney, userSessionSchema };
+//# sourceMappingURL=index.mjs.map