@c15t/backend 0.0.1-rc.10

package/dist/db/schema/definition.d.ts

@@ -0,0 +1,1100 @@
+import type { C15TOptions } from '../../types';
+import type { InferTableShape } from './schemas';
+/**
+ * Retrieves all consent-related database table definitions
+ *
+ * This function combines the core tables with any additional tables
+ * defined by plugins. It handles merging plugin-defined fields with
+ * the standard tables and ensures all table definitions are properly
+ * structured for use by database adapters.
+ *
+ * @param options - The c15t configuration options
+ * @returns A complete schema mapping containing all table definitions
+ *
+ * @remarks
+ * Each table definition includes both field definitions and the physical
+ * entity name used in the database. Plugins can extend core tables by
+ * defining additional fields, which will be merged with the standard fields.
+ *
+ * @example
+ * ```typescript
+ * // Get all tables with default configuration
+ * const tables = getConsentTables(options);
+ *
+ * // Access fields for the consent table
+ * const consentFields = tables.consent.fields;
+ * ```
+ */
+export declare const getConsentTables: (options: C15TOptions) => {
+    subject: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            isIdentified: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            externalId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            identityProvider: import("zod").ZodOptional<import("zod").ZodString>;
+            lastIpAddress: import("zod").ZodOptional<import("zod").ZodString>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            isIdentified: boolean;
+            externalId?: string | null | undefined;
+            identityProvider?: string | undefined;
+            lastIpAddress?: string | undefined;
+        }, {
+            id: string;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+            isIdentified?: boolean | undefined;
+            externalId?: string | null | undefined;
+            identityProvider?: string | undefined;
+            lastIpAddress?: string | undefined;
+        }>;
+        fields: {
+            isIdentified: {
+                type: string;
+                defaultValue: () => boolean;
+                required: boolean;
+                fieldName: string;
+            };
+            externalId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            identityProvider: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            lastIpAddress: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+            updatedAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+            subjectTimezone: {
+                type: string;
+                required: boolean;
+                defaultValue: "UTC";
+                fieldName: string;
+            };
+        };
+        order: number;
+    };
+    consentPurpose: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            code: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            isEssential: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            dataCategory: import("zod").ZodOptional<import("zod").ZodString>;
+            legalBasis: import("zod").ZodOptional<import("zod").ZodString>;
+            isActive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            code: string;
+            createdAt: Date;
+            isActive: boolean;
+            updatedAt: Date;
+            name: string;
+            description: string;
+            isEssential: boolean;
+            dataCategory?: string | undefined;
+            legalBasis?: string | undefined;
+        }, {
+            id: string;
+            code: string;
+            name: string;
+            description: string;
+            createdAt?: Date | undefined;
+            isActive?: boolean | undefined;
+            updatedAt?: Date | undefined;
+            isEssential?: boolean | undefined;
+            dataCategory?: string | undefined;
+            legalBasis?: string | undefined;
+        }>;
+        fields: {
+            code: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            name: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            description: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            isEssential: {
+                type: string;
+                defaultValue: () => boolean;
+                required: boolean;
+                fieldName: string;
+            };
+            dataCategory: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            legalBasis: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            isActive: {
+                type: string;
+                defaultValue: boolean;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+            updatedAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        order: number;
+    };
+    consentPolicy: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            version: import("zod").ZodString;
+            name: import("zod").ZodString;
+            effectiveDate: import("zod").ZodDate;
+            expirationDate: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodDate>>;
+            content: import("zod").ZodString;
+            contentHash: import("zod").ZodString;
+            isActive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            createdAt: Date;
+            isActive: boolean;
+            updatedAt: Date;
+            version: string;
+            name: string;
+            effectiveDate: Date;
+            content: string;
+            contentHash: string;
+            expirationDate?: Date | null | undefined;
+        }, {
+            id: string;
+            version: string;
+            name: string;
+            effectiveDate: Date;
+            content: string;
+            contentHash: string;
+            createdAt?: Date | undefined;
+            isActive?: boolean | undefined;
+            updatedAt?: Date | undefined;
+            expirationDate?: Date | null | undefined;
+        }>;
+        fields: {
+            version: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            name: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            effectiveDate: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            expirationDate: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            content: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            contentHash: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            isActive: {
+                type: string;
+                defaultValue: boolean;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        order: number;
+    };
+    domain: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            allowedOrigins: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>>;
+            isVerified: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            isActive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            createdAt: Date;
+            isActive: boolean;
+            updatedAt: Date;
+            name: string;
+            allowedOrigins: string[];
+            isVerified: boolean;
+            description?: string | undefined;
+        }, {
+            id: string;
+            name: string;
+            createdAt?: Date | undefined;
+            isActive?: boolean | undefined;
+            updatedAt?: Date | undefined;
+            description?: string | undefined;
+            allowedOrigins?: string[] | undefined;
+            isVerified?: boolean | undefined;
+        }>;
+        fields: {
+            name: {
+                type: string;
+                required: boolean;
+                unique: boolean;
+                fieldName: string;
+            };
+            description: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            allowedOrigins: {
+                type: string;
+                defaultValue: () => never[];
+                required: boolean;
+                fieldName: string;
+            };
+            isVerified: {
+                type: string;
+                defaultValue: boolean;
+                required: boolean;
+                fieldName: string;
+            };
+            isActive: {
+                type: string;
+                defaultValue: boolean;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+            updatedAt: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        order: number;
+    };
+    consent: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            subjectId: import("zod").ZodString;
+            domainId: import("zod").ZodString;
+            purposeIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+            metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            policyId: import("zod").ZodOptional<import("zod").ZodString>;
+            ipAddress: import("zod").ZodOptional<import("zod").ZodString>;
+            userAgent: import("zod").ZodOptional<import("zod").ZodString>;
+            status: import("zod").ZodDefault<import("zod").ZodEnum<["active", "withdrawn", "expired"]>>;
+            withdrawalReason: import("zod").ZodOptional<import("zod").ZodString>;
+            givenAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            validUntil: import("zod").ZodOptional<import("zod").ZodDate>;
+            isActive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            history: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                actionType: import("zod").ZodEnum<["given", "withdrawn", "updated", "expired"]>;
+                timestamp: import("zod").ZodDate;
+                details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                previousState: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                newState: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, "strip", import("zod").ZodTypeAny, {
+                actionType: "withdrawn" | "expired" | "given" | "updated";
+                timestamp: Date;
+                details?: Record<string, unknown> | undefined;
+                previousState?: Record<string, unknown> | undefined;
+                newState?: Record<string, unknown> | undefined;
+            }, {
+                actionType: "withdrawn" | "expired" | "given" | "updated";
+                timestamp: Date;
+                details?: Record<string, unknown> | undefined;
+                previousState?: Record<string, unknown> | undefined;
+                newState?: Record<string, unknown> | undefined;
+            }>, "many">>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            subjectId: string;
+            status: "active" | "withdrawn" | "expired";
+            domainId: string;
+            purposeIds: string[];
+            givenAt: Date;
+            isActive: boolean;
+            history: {
+                actionType: "withdrawn" | "expired" | "given" | "updated";
+                timestamp: Date;
+                details?: Record<string, unknown> | undefined;
+                previousState?: Record<string, unknown> | undefined;
+                newState?: Record<string, unknown> | undefined;
+            }[];
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            policyId?: string | undefined;
+            withdrawalReason?: string | undefined;
+            validUntil?: Date | undefined;
+        }, {
+            id: string;
+            subjectId: string;
+            domainId: string;
+            purposeIds: string[];
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+            status?: "active" | "withdrawn" | "expired" | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            policyId?: string | undefined;
+            withdrawalReason?: string | undefined;
+            givenAt?: Date | undefined;
+            validUntil?: Date | undefined;
+            isActive?: boolean | undefined;
+            history?: {
+                actionType: "withdrawn" | "expired" | "given" | "updated";
+                timestamp: Date;
+                details?: Record<string, unknown> | undefined;
+                previousState?: Record<string, unknown> | undefined;
+                newState?: Record<string, unknown> | undefined;
+            }[] | undefined;
+        }>;
+        fields: {
+            subjectId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            domainId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            purposeIds: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                    type: string;
+                };
+            };
+            metadata: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            policyId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            ipAddress: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            userAgent: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            status: {
+                type: string;
+                defaultValue: () => string;
+                required: boolean;
+                fieldName: string;
+            };
+            withdrawalReason: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            givenAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+            validUntil: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                transform: {
+                    input: (val: Date | undefined, data: Record<string, unknown>) => Date | undefined;
+                };
+            };
+            isActive: {
+                type: string;
+                defaultValue: boolean;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        order: number;
+    };
+    consentPurposeJunction: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            consentId: import("zod").ZodString;
+            consentPurposeId: import("zod").ZodString;
+            status: import("zod").ZodDefault<import("zod").ZodEnum<["active", "withdrawn"]>>;
+            metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            status: "active" | "withdrawn";
+            createdAt: Date;
+            consentId: string;
+            updatedAt: Date;
+            consentPurposeId: string;
+            metadata?: Record<string, string | number | boolean> | undefined;
+        }, {
+            id: string;
+            consentId: string;
+            consentPurposeId: string;
+            status?: "active" | "withdrawn" | undefined;
+            metadata?: Record<string, string | number | boolean> | undefined;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+        }>;
+        fields: {
+            consentId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            purposeId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            status: {
+                type: string;
+                defaultValue: () => string;
+                required: boolean;
+                fieldName: string;
+            };
+            metadata: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+            updatedAt: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        uniqueConstraints: {
+            name: string;
+            fields: string[];
+        }[];
+        order: number;
+    };
+    consentRecord: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            subjectId: import("zod").ZodString;
+            consentId: import("zod").ZodOptional<import("zod").ZodString>;
+            actionType: import("zod").ZodString;
+            details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            actionType: string;
+            subjectId: string;
+            createdAt: Date;
+            updatedAt: Date;
+            details?: Record<string, unknown> | undefined;
+            consentId?: string | undefined;
+        }, {
+            id: string;
+            actionType: string;
+            subjectId: string;
+            createdAt?: Date | undefined;
+            details?: Record<string, unknown> | undefined;
+            consentId?: string | undefined;
+            updatedAt?: Date | undefined;
+        }>;
+        fields: {
+            subjectId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            consentId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            actionType: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            details: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        order: number;
+    };
+    consentGeoLocation: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            consentId: import("zod").ZodString;
+            ip: import("zod").ZodString;
+            country: import("zod").ZodOptional<import("zod").ZodString>;
+            region: import("zod").ZodOptional<import("zod").ZodString>;
+            city: import("zod").ZodOptional<import("zod").ZodString>;
+            latitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            longitude: import("zod").ZodOptional<import("zod").ZodNumber>;
+            timezone: import("zod").ZodOptional<import("zod").ZodString>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            createdAt: Date;
+            consentId: string;
+            ip: string;
+            updatedAt: Date;
+            country?: string | undefined;
+            region?: string | undefined;
+            city?: string | undefined;
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            timezone?: string | undefined;
+        }, {
+            id: string;
+            consentId: string;
+            ip: string;
+            createdAt?: Date | undefined;
+            country?: string | undefined;
+            region?: string | undefined;
+            city?: string | undefined;
+            latitude?: number | undefined;
+            longitude?: number | undefined;
+            timezone?: string | undefined;
+            updatedAt?: Date | undefined;
+        }>;
+        fields: {
+            consentId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            ip: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            country: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            region: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            city: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            latitude: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            longitude: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            timezone: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        indexes: {
+            name: string;
+            fields: string[];
+        }[];
+        order: number;
+    };
+    consentWithdrawal: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            consentId: import("zod").ZodString;
+            subjectId: import("zod").ZodString;
+            withdrawalReason: import("zod").ZodOptional<import("zod").ZodString>;
+            withdrawalMethod: import("zod").ZodDefault<import("zod").ZodEnum<["subject-initiated", "automatic-expiry", "admin", "api", "other"]>>;
+            ipAddress: import("zod").ZodOptional<import("zod").ZodString>;
+            userAgent: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+            updatedAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            subjectId: string;
+            createdAt: Date;
+            consentId: string;
+            updatedAt: Date;
+            withdrawalMethod: "subject-initiated" | "automatic-expiry" | "admin" | "api" | "other";
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            withdrawalReason?: string | undefined;
+        }, {
+            id: string;
+            subjectId: string;
+            consentId: string;
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            createdAt?: Date | undefined;
+            withdrawalReason?: string | undefined;
+            updatedAt?: Date | undefined;
+            withdrawalMethod?: "subject-initiated" | "automatic-expiry" | "admin" | "api" | "other" | undefined;
+        }>;
+        fields: {
+            consentId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            subjectId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            withdrawalReason: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            withdrawalMethod: {
+                type: string;
+                defaultValue: () => string;
+                required: boolean;
+                fieldName: string;
+            };
+            ipAddress: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            userAgent: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            metadata: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        uniqueConstraints: {
+            name: string;
+            fields: string[];
+        }[];
+        indexes: {
+            name: string;
+            fields: string[];
+        }[];
+        order: number;
+    };
+    auditLog: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            entityType: import("zod").ZodString;
+            entityId: import("zod").ZodString;
+            actionType: import("zod").ZodString;
+            subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+            ipAddress: import("zod").ZodOptional<import("zod").ZodString>;
+            userAgent: import("zod").ZodOptional<import("zod").ZodString>;
+            changes: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            entityType: string;
+            entityId: string;
+            actionType: string;
+            createdAt: Date;
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+            changes?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        }, {
+            id: string;
+            entityType: string;
+            entityId: string;
+            actionType: string;
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+            changes?: Record<string, unknown> | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            createdAt?: Date | undefined;
+        }>;
+        fields: {
+            entityType: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            entityId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            actionType: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            subjectId: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+            ipAddress: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            userAgent: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            changes: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            metadata: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+            eventTimezone: {
+                type: string;
+                required: boolean;
+                defaultValue: "UTC";
+                fieldName: string;
+            };
+        };
+        indexes: {
+            name: string;
+            fields: string[];
+        }[];
+        order: number;
+    };
+    geoLocation: {
+        entityName: string;
+        entityPrefix: string;
+        schema: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            countryCode: import("zod").ZodString;
+            countryName: import("zod").ZodString;
+            regionCode: import("zod").ZodOptional<import("zod").ZodString>;
+            regionName: import("zod").ZodOptional<import("zod").ZodString>;
+            regulatoryZones: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<["GDPR", "CCPA", "CPRA", "LGPD", "PIPEDA"]>, "many">>;
+            createdAt: import("zod").ZodDefault<import("zod").ZodDate>;
+        }, "strip", import("zod").ZodTypeAny, {
+            id: string;
+            createdAt: Date;
+            countryCode: string;
+            countryName: string;
+            regionCode?: string | undefined;
+            regionName?: string | undefined;
+            regulatoryZones?: ("GDPR" | "CCPA" | "CPRA" | "LGPD" | "PIPEDA")[] | undefined;
+        }, {
+            id: string;
+            countryCode: string;
+            countryName: string;
+            createdAt?: Date | undefined;
+            regionCode?: string | undefined;
+            regionName?: string | undefined;
+            regulatoryZones?: ("GDPR" | "CCPA" | "CPRA" | "LGPD" | "PIPEDA")[] | undefined;
+        }>;
+        fields: {
+            countryCode: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            countryName: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            regionCode: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            regionName: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+            };
+            regulatoryZones: {
+                type: string;
+                required: boolean;
+                fieldName: string;
+                transformer: {
+                    input: (value: string[]) => string;
+                    output: (value: string) => any;
+                };
+            };
+            createdAt: {
+                type: string;
+                defaultValue: () => Date;
+                required: boolean;
+                fieldName: string;
+            };
+        };
+        indexes: {
+            name: string;
+            fields: string[];
+        }[];
+        order: number;
+    };
+};
+/**
+ * Type representing the complete database schema for c15t
+ *
+ * This type captures the full structure of all tables in the database,
+ * including core tables and any plugin-defined tables. It's derived from
+ * the return type of `getConsentTables()`.
+ *
+ * @remarks
+ * This is a key type for type-safety throughout the codebase, as it
+ * ensures that table names and field references are validated at compile time.
+ * It's used as a basis for many other type definitions in the database layer.
+ *
+ * @example
+ * ```typescript
+ * // Type-safe reference to a specific table
+ * function processTable<TableName extends keyof C15TDBSchema>(
+ *   tableName: TableName,
+ *   data: Record<string, unknown>
+ * ) {
+ *   const tableFields = getConsentTables(options)[tableName].fields;
+ *   // Process with type safety...
+ * }
+ * ```
+ */
+export type C15TDBSchema = ReturnType<typeof getConsentTables>;
+/**
+ * Type to get all output fields of a table by its name
+ * This type extracts only the fields that are included in output operations,
+ * automatically excluding fields marked with { returned: false }.
+ * It also resolves relationships between tables.
+ */
+export type EntityOutputFields<TableName extends keyof C15TDBSchema> = InferTableShape<TableName>;
+/**
+ * Type to get all input fields of a table by its name
+ * This type extracts only the fields that are allowed for input operations,
+ * automatically excluding fields marked with { input: false }.
+ */
+export type EntityInputFields<TableName extends keyof C15TDBSchema> = Omit<InferTableShape<TableName>, 'id' | 'createdAt' | 'updatedAt'>;
+/**
+ * Validates output data against table schema using Zod
+ *
+ * This function validates and transforms output data according to the
+ * schema definition for a specific table. It ensures that all values match
+ * their expected types and excludes fields marked as not to be returned.
+ *
+ * @typeParam TableName - The table name from C15TDBSchema
+ * @param tableName - The name of the table to validate against
+ * @param data - The data to validate
+ * @param options - The C15TOptions instance
+ * @returns Validated and typed data
+ * @throws {Error} If the table is not found or validation fails
+ *
+ * @remarks
+ * This function is particularly useful for validating data received from
+ * external sources or database adapters before processing it in application logic.
+ *
+ * @example
+ * ```typescript
+ * // Validate data retrieved from an external API
+ * try {
+ *   const validSubjectOutput = validateEntityOutput(
+ *     'subject',
+ *     fetchedSubjectData,
+ *     options
+ *   );
+ *
+ *   // validSubjectOutput is now typed as EntityOutputFields<'subject'>
+ *   displaySubjectProfile(validSubjectOutput);
+ * } catch (error) {
+ *   console.error('Output validation failed:', error.message);
+ * }
+ * ```
+ */
+export declare function validateEntityOutput<TableName extends keyof C15TDBSchema>(tableName: TableName, data: Record<string, unknown>, options: C15TOptions): EntityOutputFields<TableName>;
+//# sourceMappingURL=definition.d.ts.map