emr-types/dist/schemas/shared-schemas.d.ts

Comprehensive TypeScript Types Library for Electronic Medical Record (EMR) Applications - Domain-Driven Design with Zod Validation

import { z } from 'zod';
import { Status, Priority } from '../domains/shared';
export declare const IdSchema: z.ZodBranded<z.ZodString, "Id">;
export declare const TimestampSchema: z.ZodDate;
export declare const MoneySchema: z.ZodObject<{
    amount: z.ZodNumber;
    currency: z.ZodString;
    precision: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    amount: number;
    currency: string;
    precision: number;
}, {
    amount: number;
    currency: string;
    precision?: number | undefined;
}>;
export declare const StatusSchema: z.ZodNativeEnum<typeof Status>;
export declare const PrioritySchema: z.ZodNativeEnum<typeof Priority>;
export declare const IdValueObjectSchema: z.ZodObject<{
    value: z.ZodBranded<z.ZodString, "Id">;
    format: z.ZodEnum<["uuid", "auto-increment", "custom"]>;
    createdAt: z.ZodDate;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    value: string & z.BRAND<"Id">;
    createdAt: Date;
    format: "uuid" | "custom" | "auto-increment";
    metadata?: Record<string, unknown> | undefined;
}, {
    value: string;
    createdAt: Date;
    format: "uuid" | "custom" | "auto-increment";
    metadata?: Record<string, unknown> | undefined;
}>;
export declare const TimestampValueObjectSchema: z.ZodObject<{
    value: z.ZodDate;
    timezone: z.ZodOptional<z.ZodString>;
    format: z.ZodOptional<z.ZodString>;
    createdAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    value: Date;
    createdAt: Date;
    format?: string | undefined;
    timezone?: string | undefined;
}, {
    value: Date;
    createdAt: Date;
    format?: string | undefined;
    timezone?: string | undefined;
}>;
export declare const MoneyValueObjectSchema: z.ZodObject<{
    value: z.ZodObject<{
        amount: z.ZodNumber;
        currency: z.ZodString;
        precision: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        amount: number;
        currency: string;
        precision: number;
    }, {
        amount: number;
        currency: string;
        precision?: number | undefined;
    }>;
    exchangeRate: z.ZodOptional<z.ZodNumber>;
    baseCurrency: z.ZodOptional<z.ZodString>;
    createdAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    value: {
        amount: number;
        currency: string;
        precision: number;
    };
    createdAt: Date;
    exchangeRate?: number | undefined;
    baseCurrency?: string | undefined;
}, {
    value: {
        amount: number;
        currency: string;
        precision?: number | undefined;
    };
    createdAt: Date;
    exchangeRate?: number | undefined;
    baseCurrency?: string | undefined;
}>;
export declare const PaginationSchema: z.ZodObject<{
    page: z.ZodNumber;
    limit: z.ZodNumber;
    total: z.ZodNumber;
    totalPages: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
}, {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
}>;
export declare const SortSchema: z.ZodObject<{
    field: z.ZodString;
    direction: z.ZodEnum<["asc", "desc"]>;
}, "strip", z.ZodTypeAny, {
    field: string;
    direction: "asc" | "desc";
}, {
    field: string;
    direction: "asc" | "desc";
}>;
export declare const FilterSchema: z.ZodObject<{
    field: z.ZodString;
    operator: z.ZodEnum<["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "like", "ilike"]>;
    value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">]>;
}, "strip", z.ZodTypeAny, {
    value: string | number | boolean | (string | number)[];
    field: string;
    operator: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "like" | "ilike";
}, {
    value: string | number | boolean | (string | number)[];
    field: string;
    operator: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "like" | "ilike";
}>;
export declare const SearchSchema: z.ZodObject<{
    query: z.ZodString;
    fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    fuzzy: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    query: string;
    fields?: string[] | undefined;
    fuzzy?: boolean | undefined;
}, {
    query: string;
    fields?: string[] | undefined;
    fuzzy?: boolean | undefined;
}>;
export declare const ApiResponseSchema: z.ZodObject<{
    success: z.ZodBoolean;
    data: z.ZodOptional<z.ZodUnknown>;
    message: z.ZodOptional<z.ZodString>;
    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    meta: z.ZodOptional<z.ZodObject<{
        timestamp: z.ZodDate;
        requestId: z.ZodOptional<z.ZodString>;
        version: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    }, {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    success: boolean;
    errors?: string[] | undefined;
    message?: string | undefined;
    data?: unknown;
    meta?: {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    } | undefined;
}, {
    success: boolean;
    errors?: string[] | undefined;
    message?: string | undefined;
    data?: unknown;
    meta?: {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    } | undefined;
}>;
export declare const PaginatedResponseSchema: z.ZodObject<{
    data: z.ZodArray<z.ZodUnknown, "many">;
    pagination: z.ZodObject<{
        page: z.ZodNumber;
        limit: z.ZodNumber;
        total: z.ZodNumber;
        totalPages: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }>;
    meta: z.ZodOptional<z.ZodObject<{
        timestamp: z.ZodDate;
        requestId: z.ZodOptional<z.ZodString>;
        version: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    }, {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
    data: unknown[];
    meta?: {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    } | undefined;
}, {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
    data: unknown[];
    meta?: {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    } | undefined;
}>;
export declare const ErrorResponseSchema: z.ZodObject<{
    success: z.ZodLiteral<false>;
    error: z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
        details: z.ZodOptional<z.ZodUnknown>;
        stack: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        message: string;
        code: string;
        details?: unknown;
        stack?: string | undefined;
    }, {
        message: string;
        code: string;
        details?: unknown;
        stack?: string | undefined;
    }>;
    meta: z.ZodOptional<z.ZodObject<{
        timestamp: z.ZodDate;
        requestId: z.ZodOptional<z.ZodString>;
        version: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    }, {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    error: {
        message: string;
        code: string;
        details?: unknown;
        stack?: string | undefined;
    };
    success: false;
    meta?: {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    } | undefined;
}, {
    error: {
        message: string;
        code: string;
        details?: unknown;
        stack?: string | undefined;
    };
    success: false;
    meta?: {
        timestamp: Date;
        requestId?: string | undefined;
        version?: string | undefined;
    } | undefined;
}>;
export declare const ValidationErrorSchema: z.ZodObject<{
    field: z.ZodString;
    message: z.ZodString;
    code: z.ZodOptional<z.ZodString>;
    value: z.ZodOptional<z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    message: string;
    field: string;
    value?: unknown;
    code?: string | undefined;
}, {
    message: string;
    field: string;
    value?: unknown;
    code?: string | undefined;
}>;
export declare const ValidationResultSchema: z.ZodObject<{
    isValid: z.ZodBoolean;
    errors: z.ZodArray<z.ZodObject<{
        field: z.ZodString;
        message: z.ZodString;
        code: z.ZodOptional<z.ZodString>;
        value: z.ZodOptional<z.ZodUnknown>;
    }, "strip", z.ZodTypeAny, {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }, {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }>, "many">;
    warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
        field: z.ZodString;
        message: z.ZodString;
        code: z.ZodOptional<z.ZodString>;
        value: z.ZodOptional<z.ZodUnknown>;
    }, "strip", z.ZodTypeAny, {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }, {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    isValid: boolean;
    errors: {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }[];
    warnings?: {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }[] | undefined;
}, {
    isValid: boolean;
    errors: {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }[];
    warnings?: {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }[] | undefined;
}>;
export declare const AuditMetadataSchema: z.ZodObject<{
    createdAt: z.ZodDate;
    createdBy: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
    updatedAt: z.ZodOptional<z.ZodDate>;
    updatedBy: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
    deletedAt: z.ZodOptional<z.ZodDate>;
    deletedBy: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
    version: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    createdAt: Date;
    updatedAt?: Date | undefined;
    createdBy?: (string & z.BRAND<"Id">) | undefined;
    updatedBy?: (string & z.BRAND<"Id">) | undefined;
    deletedAt?: Date | undefined;
    version?: number | undefined;
    deletedBy?: (string & z.BRAND<"Id">) | undefined;
}, {
    createdAt: Date;
    updatedAt?: Date | undefined;
    createdBy?: string | undefined;
    updatedBy?: string | undefined;
    deletedAt?: Date | undefined;
    version?: number | undefined;
    deletedBy?: string | undefined;
}>;
export declare const AuditLogSchema: z.ZodObject<{
    id: z.ZodBranded<z.ZodString, "Id">;
    entityType: z.ZodString;
    entityId: z.ZodBranded<z.ZodString, "Id">;
    action: z.ZodEnum<["create", "update", "delete", "restore"]>;
    changes: z.ZodOptional<z.ZodObject<{
        before: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        after: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        before?: Record<string, unknown> | undefined;
        after?: Record<string, unknown> | undefined;
    }, {
        before?: Record<string, unknown> | undefined;
        after?: Record<string, unknown> | undefined;
    }>>;
    userId: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
    userAgent: z.ZodOptional<z.ZodString>;
    ipAddress: z.ZodOptional<z.ZodString>;
    timestamp: z.ZodDate;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    id: string & z.BRAND<"Id">;
    timestamp: Date;
    entityType: string;
    entityId: string & z.BRAND<"Id">;
    action: "create" | "update" | "delete" | "restore";
    metadata?: Record<string, unknown> | undefined;
    userId?: (string & z.BRAND<"Id">) | undefined;
    userAgent?: string | undefined;
    ipAddress?: string | undefined;
    changes?: {
        before?: Record<string, unknown> | undefined;
        after?: Record<string, unknown> | undefined;
    } | undefined;
}, {
    id: string;
    timestamp: Date;
    entityType: string;
    entityId: string;
    action: "create" | "update" | "delete" | "restore";
    metadata?: Record<string, unknown> | undefined;
    userId?: string | undefined;
    userAgent?: string | undefined;
    ipAddress?: string | undefined;
    changes?: {
        before?: Record<string, unknown> | undefined;
        after?: Record<string, unknown> | undefined;
    } | undefined;
}>;
export declare const FileSchema: z.ZodObject<{
    id: z.ZodBranded<z.ZodString, "Id">;
    name: z.ZodString;
    originalName: z.ZodString;
    mimeType: z.ZodString;
    size: z.ZodNumber;
    url: z.ZodString;
    path: z.ZodOptional<z.ZodString>;
    hash: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
    createdBy: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
}, "strip", z.ZodTypeAny, {
    id: string & z.BRAND<"Id">;
    createdAt: Date;
    name: string;
    url: string;
    size: number;
    mimeType: string;
    originalName: string;
    createdBy?: (string & z.BRAND<"Id">) | undefined;
    metadata?: Record<string, unknown> | undefined;
    path?: string | undefined;
    hash?: string | undefined;
}, {
    id: string;
    createdAt: Date;
    name: string;
    url: string;
    size: number;
    mimeType: string;
    originalName: string;
    createdBy?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
    path?: string | undefined;
    hash?: string | undefined;
}>;
export declare const FileUploadSchema: z.ZodObject<{
    file: z.ZodType<import("buffer").File, z.ZodTypeDef, import("buffer").File>;
    category: z.ZodOptional<z.ZodString>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    file: import("buffer").File;
    category?: string | undefined;
    tags?: string[] | undefined;
    metadata?: Record<string, unknown> | undefined;
}, {
    file: import("buffer").File;
    category?: string | undefined;
    tags?: string[] | undefined;
    metadata?: Record<string, unknown> | undefined;
}>;
export declare const NotificationSchema: z.ZodObject<{
    id: z.ZodBranded<z.ZodString, "Id">;
    type: z.ZodEnum<["info", "success", "warning", "error"]>;
    title: z.ZodString;
    message: z.ZodString;
    recipientId: z.ZodBranded<z.ZodString, "Id">;
    recipientType: z.ZodEnum<["user", "patient", "provider"]>;
    channel: z.ZodEnum<["email", "sms", "push", "in-app"]>;
    status: z.ZodEnum<["pending", "sent", "delivered", "failed"]>;
    scheduledAt: z.ZodOptional<z.ZodDate>;
    sentAt: z.ZodOptional<z.ZodDate>;
    deliveredAt: z.ZodOptional<z.ZodDate>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    type: "warning" | "error" | "info" | "success";
    id: string & z.BRAND<"Id">;
    createdAt: Date;
    status: "pending" | "sent" | "delivered" | "failed";
    title: string;
    message: string;
    recipientId: string & z.BRAND<"Id">;
    recipientType: "patient" | "provider" | "user";
    channel: "push" | "sms" | "email" | "in-app";
    metadata?: Record<string, unknown> | undefined;
    scheduledAt?: Date | undefined;
    sentAt?: Date | undefined;
    deliveredAt?: Date | undefined;
}, {
    type: "warning" | "error" | "info" | "success";
    id: string;
    createdAt: Date;
    status: "pending" | "sent" | "delivered" | "failed";
    title: string;
    message: string;
    recipientId: string;
    recipientType: "patient" | "provider" | "user";
    channel: "push" | "sms" | "email" | "in-app";
    metadata?: Record<string, unknown> | undefined;
    scheduledAt?: Date | undefined;
    sentAt?: Date | undefined;
    deliveredAt?: Date | undefined;
}>;
export declare const SettingsSchema: z.ZodObject<{
    id: z.ZodBranded<z.ZodString, "Id">;
    key: z.ZodString;
    value: z.ZodUnknown;
    type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
    category: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    isPublic: z.ZodDefault<z.ZodBoolean>;
    isRequired: z.ZodDefault<z.ZodBoolean>;
    validation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    createdAt: z.ZodDate;
    updatedAt: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    type: "string" | "number" | "boolean" | "object" | "array";
    id: string & z.BRAND<"Id">;
    createdAt: Date;
    isRequired: boolean;
    key: string;
    isPublic: boolean;
    value?: unknown;
    category?: string | undefined;
    updatedAt?: Date | undefined;
    description?: string | undefined;
    validation?: Record<string, unknown> | undefined;
}, {
    type: "string" | "number" | "boolean" | "object" | "array";
    id: string;
    createdAt: Date;
    key: string;
    value?: unknown;
    category?: string | undefined;
    updatedAt?: Date | undefined;
    description?: string | undefined;
    validation?: Record<string, unknown> | undefined;
    isRequired?: boolean | undefined;
    isPublic?: boolean | undefined;
}>;
export declare const SharedValidationUtils: {
    isValidUUID: (uuid: string) => boolean;
    isValidEmail: (email: string) => boolean;
    isValidPhoneNumber: (phone: string) => boolean;
    isValidCurrency: (currency: string) => boolean;
    isValidMoney: (amount: number, currency: string) => boolean;
    validatePagination: (page: number, limit: number) => {
        isValid: boolean;
        errors: string[];
    };
    validateSort: (field: string, direction: string) => {
        isValid: boolean;
        errors: string[];
    };
    validateFilter: (field: string, operator: string, value: unknown) => {
        isValid: boolean;
        errors: string[];
    };
};
export type Pagination = z.infer<typeof PaginationSchema>;
export type Sort = z.infer<typeof SortSchema>;
export type Filter = z.infer<typeof FilterSchema>;
export type Search = z.infer<typeof SearchSchema>;
export type ApiResponse = z.infer<typeof ApiResponseSchema>;
export type PaginatedResponse = z.infer<typeof PaginatedResponseSchema>;
export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
export type ValidationError = z.infer<typeof ValidationErrorSchema>;
export type ValidationResult = z.infer<typeof ValidationResultSchema>;
export type AuditMetadata = z.infer<typeof AuditMetadataSchema>;
export type AuditLog = z.infer<typeof AuditLogSchema>;
export type File = z.infer<typeof FileSchema>;
export type FileUpload = z.infer<typeof FileUploadSchema>;
export type Notification = z.infer<typeof NotificationSchema>;
export type Settings = z.infer<typeof SettingsSchema>;
export declare const SharedSchemas: {
    readonly Id: z.ZodBranded<z.ZodString, "Id">;
    readonly Timestamp: z.ZodDate;
    readonly Money: z.ZodObject<{
        amount: z.ZodNumber;
        currency: z.ZodString;
        precision: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        amount: number;
        currency: string;
        precision: number;
    }, {
        amount: number;
        currency: string;
        precision?: number | undefined;
    }>;
    readonly Status: z.ZodNativeEnum<typeof Status>;
    readonly Priority: z.ZodNativeEnum<typeof Priority>;
    readonly IdValueObject: z.ZodObject<{
        value: z.ZodBranded<z.ZodString, "Id">;
        format: z.ZodEnum<["uuid", "auto-increment", "custom"]>;
        createdAt: z.ZodDate;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        value: string & z.BRAND<"Id">;
        createdAt: Date;
        format: "uuid" | "custom" | "auto-increment";
        metadata?: Record<string, unknown> | undefined;
    }, {
        value: string;
        createdAt: Date;
        format: "uuid" | "custom" | "auto-increment";
        metadata?: Record<string, unknown> | undefined;
    }>;
    readonly TimestampValueObject: z.ZodObject<{
        value: z.ZodDate;
        timezone: z.ZodOptional<z.ZodString>;
        format: z.ZodOptional<z.ZodString>;
        createdAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        value: Date;
        createdAt: Date;
        format?: string | undefined;
        timezone?: string | undefined;
    }, {
        value: Date;
        createdAt: Date;
        format?: string | undefined;
        timezone?: string | undefined;
    }>;
    readonly MoneyValueObject: z.ZodObject<{
        value: z.ZodObject<{
            amount: z.ZodNumber;
            currency: z.ZodString;
            precision: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            amount: number;
            currency: string;
            precision: number;
        }, {
            amount: number;
            currency: string;
            precision?: number | undefined;
        }>;
        exchangeRate: z.ZodOptional<z.ZodNumber>;
        baseCurrency: z.ZodOptional<z.ZodString>;
        createdAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        value: {
            amount: number;
            currency: string;
            precision: number;
        };
        createdAt: Date;
        exchangeRate?: number | undefined;
        baseCurrency?: string | undefined;
    }, {
        value: {
            amount: number;
            currency: string;
            precision?: number | undefined;
        };
        createdAt: Date;
        exchangeRate?: number | undefined;
        baseCurrency?: string | undefined;
    }>;
    readonly Pagination: z.ZodObject<{
        page: z.ZodNumber;
        limit: z.ZodNumber;
        total: z.ZodNumber;
        totalPages: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }>;
    readonly Sort: z.ZodObject<{
        field: z.ZodString;
        direction: z.ZodEnum<["asc", "desc"]>;
    }, "strip", z.ZodTypeAny, {
        field: string;
        direction: "asc" | "desc";
    }, {
        field: string;
        direction: "asc" | "desc";
    }>;
    readonly Filter: z.ZodObject<{
        field: z.ZodString;
        operator: z.ZodEnum<["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "like", "ilike"]>;
        value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">]>;
    }, "strip", z.ZodTypeAny, {
        value: string | number | boolean | (string | number)[];
        field: string;
        operator: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "like" | "ilike";
    }, {
        value: string | number | boolean | (string | number)[];
        field: string;
        operator: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "like" | "ilike";
    }>;
    readonly Search: z.ZodObject<{
        query: z.ZodString;
        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        fuzzy: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        query: string;
        fields?: string[] | undefined;
        fuzzy?: boolean | undefined;
    }, {
        query: string;
        fields?: string[] | undefined;
        fuzzy?: boolean | undefined;
    }>;
    readonly ApiResponse: z.ZodObject<{
        success: z.ZodBoolean;
        data: z.ZodOptional<z.ZodUnknown>;
        message: z.ZodOptional<z.ZodString>;
        errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        meta: z.ZodOptional<z.ZodObject<{
            timestamp: z.ZodDate;
            requestId: z.ZodOptional<z.ZodString>;
            version: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        }, {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        success: boolean;
        errors?: string[] | undefined;
        message?: string | undefined;
        data?: unknown;
        meta?: {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        } | undefined;
    }, {
        success: boolean;
        errors?: string[] | undefined;
        message?: string | undefined;
        data?: unknown;
        meta?: {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        } | undefined;
    }>;
    readonly PaginatedResponse: z.ZodObject<{
        data: z.ZodArray<z.ZodUnknown, "many">;
        pagination: z.ZodObject<{
            page: z.ZodNumber;
            limit: z.ZodNumber;
            total: z.ZodNumber;
            totalPages: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            page: number;
            limit: number;
            total: number;
            totalPages: number;
        }, {
            page: number;
            limit: number;
            total: number;
            totalPages: number;
        }>;
        meta: z.ZodOptional<z.ZodObject<{
            timestamp: z.ZodDate;
            requestId: z.ZodOptional<z.ZodString>;
            version: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        }, {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        pagination: {
            page: number;
            limit: number;
            total: number;
            totalPages: number;
        };
        data: unknown[];
        meta?: {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        } | undefined;
    }, {
        pagination: {
            page: number;
            limit: number;
            total: number;
            totalPages: number;
        };
        data: unknown[];
        meta?: {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        } | undefined;
    }>;
    readonly ErrorResponse: z.ZodObject<{
        success: z.ZodLiteral<false>;
        error: z.ZodObject<{
            code: z.ZodString;
            message: z.ZodString;
            details: z.ZodOptional<z.ZodUnknown>;
            stack: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            message: string;
            code: string;
            details?: unknown;
            stack?: string | undefined;
        }, {
            message: string;
            code: string;
            details?: unknown;
            stack?: string | undefined;
        }>;
        meta: z.ZodOptional<z.ZodObject<{
            timestamp: z.ZodDate;
            requestId: z.ZodOptional<z.ZodString>;
            version: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        }, {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        error: {
            message: string;
            code: string;
            details?: unknown;
            stack?: string | undefined;
        };
        success: false;
        meta?: {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        } | undefined;
    }, {
        error: {
            message: string;
            code: string;
            details?: unknown;
            stack?: string | undefined;
        };
        success: false;
        meta?: {
            timestamp: Date;
            requestId?: string | undefined;
            version?: string | undefined;
        } | undefined;
    }>;
    readonly ValidationError: z.ZodObject<{
        field: z.ZodString;
        message: z.ZodString;
        code: z.ZodOptional<z.ZodString>;
        value: z.ZodOptional<z.ZodUnknown>;
    }, "strip", z.ZodTypeAny, {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }, {
        message: string;
        field: string;
        value?: unknown;
        code?: string | undefined;
    }>;
    readonly ValidationResult: z.ZodObject<{
        isValid: z.ZodBoolean;
        errors: z.ZodArray<z.ZodObject<{
            field: z.ZodString;
            message: z.ZodString;
            code: z.ZodOptional<z.ZodString>;
            value: z.ZodOptional<z.ZodUnknown>;
        }, "strip", z.ZodTypeAny, {
            message: string;
            field: string;
            value?: unknown;
            code?: string | undefined;
        }, {
            message: string;
            field: string;
            value?: unknown;
            code?: string | undefined;
        }>, "many">;
        warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
            field: z.ZodString;
            message: z.ZodString;
            code: z.ZodOptional<z.ZodString>;
            value: z.ZodOptional<z.ZodUnknown>;
        }, "strip", z.ZodTypeAny, {
            message: string;
            field: string;
            value?: unknown;
            code?: string | undefined;
        }, {
            message: string;
            field: string;
            value?: unknown;
            code?: string | undefined;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        isValid: boolean;
        errors: {
            message: string;
            field: string;
            value?: unknown;
            code?: string | undefined;
        }[];
        warnings?: {
            message: string;
            field: string;
            value?: unknown;
            code?: string | undefined;
        }[] | undefined;
    }, {
        isValid: boolean;
        errors: {
            message: string;
            field: string;
            value?: unknown;
            code?: string | undefined;
        }[];
        warnings?: {
            message: string;
            field: string;
            value?: unknown;
            code?: string | undefined;
        }[] | undefined;
    }>;
    readonly AuditMetadata: z.ZodObject<{
        createdAt: z.ZodDate;
        createdBy: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
        updatedAt: z.ZodOptional<z.ZodDate>;
        updatedBy: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
        deletedAt: z.ZodOptional<z.ZodDate>;
        deletedBy: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
        version: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        createdAt: Date;
        updatedAt?: Date | undefined;
        createdBy?: (string & z.BRAND<"Id">) | undefined;
        updatedBy?: (string & z.BRAND<"Id">) | undefined;
        deletedAt?: Date | undefined;
        version?: number | undefined;
        deletedBy?: (string & z.BRAND<"Id">) | undefined;
    }, {
        createdAt: Date;
        updatedAt?: Date | undefined;
        createdBy?: string | undefined;
        updatedBy?: string | undefined;
        deletedAt?: Date | undefined;
        version?: number | undefined;
        deletedBy?: string | undefined;
    }>;
    readonly AuditLog: z.ZodObject<{
        id: z.ZodBranded<z.ZodString, "Id">;
        entityType: z.ZodString;
        entityId: z.ZodBranded<z.ZodString, "Id">;
        action: z.ZodEnum<["create", "update", "delete", "restore"]>;
        changes: z.ZodOptional<z.ZodObject<{
            before: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            after: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            before?: Record<string, unknown> | undefined;
            after?: Record<string, unknown> | undefined;
        }, {
            before?: Record<string, unknown> | undefined;
            after?: Record<string, unknown> | undefined;
        }>>;
        userId: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
        userAgent: z.ZodOptional<z.ZodString>;
        ipAddress: z.ZodOptional<z.ZodString>;
        timestamp: z.ZodDate;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        id: string & z.BRAND<"Id">;
        timestamp: Date;
        entityType: string;
        entityId: string & z.BRAND<"Id">;
        action: "create" | "update" | "delete" | "restore";
        metadata?: Record<string, unknown> | undefined;
        userId?: (string & z.BRAND<"Id">) | undefined;
        userAgent?: string | undefined;
        ipAddress?: string | undefined;
        changes?: {
            before?: Record<string, unknown> | undefined;
            after?: Record<string, unknown> | undefined;
        } | undefined;
    }, {
        id: string;
        timestamp: Date;
        entityType: string;
        entityId: string;
        action: "create" | "update" | "delete" | "restore";
        metadata?: Record<string, unknown> | undefined;
        userId?: string | undefined;
        userAgent?: string | undefined;
        ipAddress?: string | undefined;
        changes?: {
            before?: Record<string, unknown> | undefined;
            after?: Record<string, unknown> | undefined;
        } | undefined;
    }>;
    readonly File: z.ZodObject<{
        id: z.ZodBranded<z.ZodString, "Id">;
        name: z.ZodString;
        originalName: z.ZodString;
        mimeType: z.ZodString;
        size: z.ZodNumber;
        url: z.ZodString;
        path: z.ZodOptional<z.ZodString>;
        hash: z.ZodOptional<z.ZodString>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        createdAt: z.ZodDate;
        createdBy: z.ZodOptional<z.ZodBranded<z.ZodString, "Id">>;
    }, "strip", z.ZodTypeAny, {
        id: string & z.BRAND<"Id">;
        createdAt: Date;
        name: string;
        url: string;
        size: number;
        mimeType: string;
        originalName: string;
        createdBy?: (string & z.BRAND<"Id">) | undefined;
        metadata?: Record<string, unknown> | undefined;
        path?: string | undefined;
        hash?: string | undefined;
    }, {
        id: string;
        createdAt: Date;
        name: string;
        url: string;
        size: number;
        mimeType: string;
        originalName: string;
        createdBy?: string | undefined;
        metadata?: Record<string, unknown> | undefined;
        path?: string | undefined;
        hash?: string | undefined;
    }>;
    readonly FileUpload: z.ZodObject<{
        file: z.ZodType<import("buffer").File, z.ZodTypeDef, import("buffer").File>;
        category: z.ZodOptional<z.ZodString>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        file: import("buffer").File;
        category?: string | undefined;
        tags?: string[] | undefined;
        metadata?: Record<string, unknown> | undefined;
    }, {
        file: import("buffer").File;
        category?: string | undefined;
        tags?: string[] | undefined;
        metadata?: Record<string, unknown> | undefined;
    }>;
    readonly Notification: z.ZodObject<{
        id: z.ZodBranded<z.ZodString, "Id">;
        type: z.ZodEnum<["info", "success", "warning", "error"]>;
        title: z.ZodString;
        message: z.ZodString;
        recipientId: z.ZodBranded<z.ZodString, "Id">;
        recipientType: z.ZodEnum<["user", "patient", "provider"]>;
        channel: z.ZodEnum<["email", "sms", "push", "in-app"]>;
        status: z.ZodEnum<["pending", "sent", "delivered", "failed"]>;
        scheduledAt: z.ZodOptional<z.ZodDate>;
        sentAt: z.ZodOptional<z.ZodDate>;
        deliveredAt: z.ZodOptional<z.ZodDate>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        createdAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        type: "warning" | "error" | "info" | "success";
        id: string & z.BRAND<"Id">;
        createdAt: Date;
        status: "pending" | "sent" | "delivered" | "failed";
        title: string;
        message: string;
        recipientId: string & z.BRAND<"Id">;
        recipientType: "patient" | "provider" | "user";
        channel: "push" | "sms" | "email" | "in-app";
        metadata?: Record<string, unknown> | undefined;
        scheduledAt?: Date | undefined;
        sentAt?: Date | undefined;
        deliveredAt?: Date | undefined;
    }, {
        type: "warning" | "error" | "info" | "success";
        id: string;
        createdAt: Date;
        status: "pending" | "sent" | "delivered" | "failed";
        title: string;
        message: string;
        recipientId: string;
        recipientType: "patient" | "provider" | "user";
        channel: "push" | "sms" | "email" | "in-app";
        metadata?: Record<string, unknown> | undefined;
        scheduledAt?: Date | undefined;
        sentAt?: Date | undefined;
        deliveredAt?: Date | undefined;
    }>;
    readonly Settings: z.ZodObject<{
        id: z.ZodBranded<z.ZodString, "Id">;
        key: z.ZodString;
        value: z.ZodUnknown;
        type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
        category: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        isPublic: z.ZodDefault<z.ZodBoolean>;
        isRequired: z.ZodDefault<z.ZodBoolean>;
        validation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        createdAt: z.ZodDate;
        updatedAt: z.ZodOptional<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        type: "string" | "number" | "boolean" | "object" | "array";
        id: string & z.BRAND<"Id">;
        createdAt: Date;
        isRequired: boolean;
        key: string;
        isPublic: boolean;
        value?: unknown;
        category?: string | undefined;
        updatedAt?: Date | undefined;
        description?: string | undefined;
        validation?: Record<string, unknown> | undefined;
    }, {
        type: "string" | "number" | "boolean" | "object" | "array";
        id: string;
        createdAt: Date;
        key: string;
        value?: unknown;
        category?: string | undefined;
        updatedAt?: Date | undefined;
        description?: string | undefined;
        validation?: Record<string, unknown> | undefined;
        isRequired?: boolean | undefined;
        isPublic?: boolean | undefined;
    }>;
    readonly ValidationUtils: {
        isValidUUID: (uuid: string) => boolean;
        isValidEmail: (email: string) => boolean;
        isValidPhoneNumber: (phone: string) => boolean;
        isValidCurrency: (currency: string) => boolean;
        isValidMoney: (amount: number, currency: string) => boolean;
        validatePagination: (page: number, limit: number) => {
            isValid: boolean;
            errors: string[];
        };
        validateSort: (field: string, direction: string) => {
            isValid: boolean;
            errors: string[];
        };
        validateFilter: (field: string, operator: string, value: unknown) => {
            isValid: boolean;
            errors: string[];
        };
    };
};
//# sourceMappingURL=shared-schemas.d.ts.map