@c15t/backend 0.0.1-rc.10

package/dist/db/schema/consent-record/schema.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating consent record entities.
+ *
+ * This defines the structure and validation rules for consent records:
+ * - Required fields: subjectId, actionType (given, withdrawn, updated, etc.)
+ * - Optional fields: consentId, details
+ * - Default current date/time for creation and update timestamps
+ *
+ * @example
+ * ```typescript
+ * const recordData = {
+ *   id: 'rec_w5qufx2a66m7xkn3ty',
+ *   subjectId: 'sub_x1pftyoufsm7xgo1kv',
+ *   consentId: 'cns_hadt8w7nngm7xmx2bn',
+ *   actionType: 'given',
+ *   details: { ip: '192.168.1.1', userAgent: 'Mozilla/5.0...' }
+ * };
+ *
+ * // Validate and parse the record data
+ * const validRecord = consentRecordSchema.parse(recordData);
+ * ```
+ */
+export declare const consentRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    subjectId: z.ZodString;
+    consentId: z.ZodOptional<z.ZodString>;
+    actionType: z.ZodString;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.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;
+}>;
+/**
+ * Type definition for Record
+ *
+ * This type represents the structure of a consent record
+ * as defined by the consentRecordSchema. It includes all fields
+ * that are part of the consent record entity.
+ */
+export type ConsentRecord = z.infer<typeof consentRecordSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/db/schema/consent-record/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-record/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;EAQ9B,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/db/schema/consent-record/table.d.ts

@@ -0,0 +1,123 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the consent record entity.
+ *
+ * This function creates a schema definition that includes all standard consent record fields
+ * and any additional fields from plugins or configuration. The resulting schema is used
+ * for database migrations, schema validation, and query building.
+ *
+ * @param options - C15T configuration options that may contain consent record table customizations
+ * @param recordFields - Additional fields from plugins to include in the consent record table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const recordTableSchema = getConsentRecordTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(recordTableSchema);
+ * ```
+ */
+export declare function getConsentRecordTable(options: C15TOptions, recordFields?: Record<string, Field>): {
+    /**
+     * The name of the consent record table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the consent record table
+     * Used to generate unique prefixed IDs for records
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the consent record table
+     */
+    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;
+    }>;
+    /**
+     * Field definitions for the consent record table
+     */
+    fields: {
+        /**
+         * Reference to the subject associated with this consent record
+         */
+        subjectId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * Optional reference to the specific consent this record is about
+         * May be null for general consent actions not related to a specific consent
+         */
+        consentId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * Type of consent action this record represents
+         * Common values: 'given', 'withdrawn', 'updated', 'expired', 'requested'
+         */
+        actionType: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Additional details about the consent action
+         * May include IP address, subject agent, reason for withdrawal, etc.
+         */
+        details: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the consent record was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Consent record table needs to be created after the subject and consent tables it references
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

package/dist/db/schema/consent-record/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-record/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,WAAW,EACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAQnC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;;;;;QAWH;;;WAGG;;;;;;;;;;QAWH;;;WAGG;;;;;;QAOH;;;WAGG;;;;;;QAOH;;;WAGG;;;;;;;;IAeJ;;;OAGG;;EAGJ"}

package/dist/db/schema/consent-record/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Record Entity Type Definitions
+ *
+ * This module contains type definitions specific to the record entity.
+ */
+import type { BaseEntityConfig } from '../types';
+/**
+ * Record entity configuration
+ * @default entityName: "record", entityPrefix: "rec"
+ */
+export interface ConsentRecordEntityConfig extends BaseEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        subjectId?: string;
+        consentId?: string;
+        actionType?: string;
+        details?: string;
+        createdAt?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/db/schema/consent-record/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-record/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IAClE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACF"}

package/dist/db/schema/consent-withdrawal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './registry';
+export * from './schema';
+export * from './table';
+//# sourceMappingURL=index.d.ts.map

package/dist/db/schema/consent-withdrawal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-withdrawal/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/db/schema/consent-withdrawal/registry.d.ts

@@ -0,0 +1,134 @@
+import type { RegistryContext } from '../../../types';
+import type { GenericEndpointContext } from '../../../types';
+import type { Withdrawal } from './schema';
+/**
+ * Creates and returns a set of consent withdrawal adapter methods to interact with the database.
+ * These methods provide a consistent interface for creating and querying consentWithdrawal records
+ * while applying hooks and enforcing data validation rules.
+ *
+ * @param adapter - The database adapter used for direct database operations
+ * @param ctx - The context object containing the database adapter, hooks, and options
+ * @returns An object containing type-safe consent withdrawal operations
+ *
+ * @example
+ * ```typescript
+ * const withdrawalAdapter = createConsentWithdrawalAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new consentWithdrawal record
+ * const consentWithdrawal = await withdrawalAdapter.createConsentWithdrawal({
+ *   consentId: 'cns_hadt8w7nngm7xmx2bn',
+ *   subjectId: 'sub_x1pftyoufsm7xgo1kv',
+ *   withdrawalReason: 'No longer wish to receive marketing emails',
+ *   withdrawalMethod: 'subject-initiated'
+ * });
+ * ```
+ */
+export declare function consentWithdrawalRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new consent withdrawal record in the database.
+     * Automatically sets creation timestamp and applies any
+     * configured hooks during the creation process.
+     *
+     * @param consentWithdrawal - Withdrawal data to create (without id and timestamp)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created consentWithdrawal record with all fields populated
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createConsentWithdrawal: (consentWithdrawal: Omit<Withdrawal, "id" | "createdAt"> & Partial<Withdrawal>, context?: GenericEndpointContext) => Promise<{
+        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;
+    }>;
+    /**
+     * Finds all consentWithdrawal records matching specified filters.
+     * Returns consentWithdrawals with processed output fields according to the schema configuration.
+     *
+     * @param subjectId - Optional subject ID to filter consentWithdrawals
+     * @param consentId - Optional consent ID to filter consentWithdrawals
+     * @param limit - Optional maximum number of records to return
+     * @returns Array of consentWithdrawal records matching the criteria
+     */
+    findConsentWithdrawals: (subjectId?: string, consentId?: string, limit?: number) => Promise<{
+        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;
+    }[]>;
+    /**
+     * Finds a consentWithdrawal record by its unique ID.
+     * Returns the consentWithdrawal with processed output fields according to the schema configuration.
+     *
+     * @param withdrawalId - The unique identifier of the consentWithdrawal record
+     * @returns The consentWithdrawal object if found, null otherwise
+     */
+    findConsentWithdrawalById: (withdrawalId: string) => Promise<{
+        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;
+    } | null>;
+    /**
+     * Finds all consentWithdrawal records for a specific subject.
+     * Returns consentWithdrawals with processed output fields according to the schema configuration.
+     *
+     * @param subjectId - The subject ID to find consentWithdrawals for
+     * @param limit - Optional maximum number of records to return
+     * @returns Array of consentWithdrawal records associated with the subject
+     */
+    findConsentWithdrawalsBySubjectId: (subjectId: string, limit?: number) => Promise<{
+        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;
+    }[]>;
+    /**
+     * Finds a consentWithdrawal record for a specific consent.
+     * Returns the consentWithdrawal with processed output fields according to the schema configuration.
+     * This is useful when you need to know if and why a specific consent was withdrawn.
+     *
+     * @param consentId - The consent ID to find consentWithdrawal for
+     * @returns The consentWithdrawal record if found, null otherwise
+     */
+    findConsentWithdrawalByConsentId: (consentId: string) => Promise<{
+        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;
+    } | null>;
+};
+//# sourceMappingURL=registry.d.ts.map

package/dist/db/schema/consent-withdrawal/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-withdrawal/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,yBAAyB,CAAC,EACzC,OAAO,EACP,GAAG,GAAG,EACN,EAAE,eAAe;IAGhB;;;;;;;;;OASG;iDAEiB,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,WAAW,CAAC,GACtD,OAAO,CAAC,UAAU,CAAC,YACV,sBAAsB;;;;;;;;;;;;IAyBjC;;;;;;;;OAQG;yCAEU,MAAM,cACN,MAAM,UACV,MAAM;;;;;;;;;;;;IAqCf;;;;;;OAMG;8CAC6C,MAAM;;;;;;;;;;;;IAmBtD;;;;;;;OAOG;mDAES,MAAM,UACT,MAAM;;;;;;;;;;;;IAyBf;;;;;;;OAOG;kDACiD,MAAM;;;;;;;;;;;;EAuB3D"}

package/dist/db/schema/consent-withdrawal/schema.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating consent withdrawal entities.
+ *
+ * This defines the structure and validation rules for consentWithdrawal records:
+ * - Required fields: consentId, subjectId
+ * - Optional fields: withdrawalReason, withdrawalMethod, ipAddress, metadata
+ * - Default current date/time for creation and update timestamps
+ *
+ * @example
+ * ```typescript
+ * const withdrawalData = {
+ *   id: 'wdr_w5qufx2a66m7xkn3ty',
+ *   consentId: 'cns_hadt8w7nngm7xmx2bn',
+ *   subjectId: 'sub_x1pftyoufsm7xgo1kv',
+ *   withdrawalReason: 'No longer wish to receive marketing emails',
+ *   withdrawalMethod: 'subject-initiated',
+ *   ipAddress: '192.168.1.1'
+ * };
+ *
+ * // Validate and parse the consentWithdrawal data
+ * const validWithdrawal = consentWithdrawalSchema.parse(withdrawalData);
+ * ```
+ */
+export declare const consentWithdrawalSchema: z.ZodObject<{
+    id: z.ZodString;
+    consentId: z.ZodString;
+    subjectId: z.ZodString;
+    withdrawalReason: z.ZodOptional<z.ZodString>;
+    withdrawalMethod: z.ZodDefault<z.ZodEnum<["subject-initiated", "automatic-expiry", "admin", "api", "other"]>>;
+    ipAddress: z.ZodOptional<z.ZodString>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.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;
+}>;
+/**
+ * Type definition for Withdrawal
+ *
+ * This type represents the structure of a consent withdrawal record
+ * as defined by the consentWithdrawalSchema. It includes all fields
+ * that are part of the consentWithdrawal entity.
+ */
+export type Withdrawal = z.infer<typeof consentWithdrawalSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/db/schema/consent-withdrawal/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-withdrawal/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAalC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/db/schema/consent-withdrawal/table.d.ts

@@ -0,0 +1,170 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the consent withdrawal entity.
+ *
+ * This function creates a schema definition that includes all standard consentWithdrawal fields
+ * and any additional fields from plugins or configuration. The resulting schema is used
+ * for database migrations, schema validation, and query building.
+ *
+ * @param options - C15T configuration options that may contain consentWithdrawal table customizations
+ * @param withdrawalFields - Additional fields from plugins to include in the consentWithdrawal table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const withdrawalTableSchema = getConsentWithdrawalTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(withdrawalTableSchema);
+ * ```
+ */
+export declare function getConsentWithdrawalTable(options: C15TOptions, withdrawalFields?: Record<string, Field>): {
+    /**
+     * The name of the consentWithdrawal table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the consentWithdrawal table
+     * Used to generate unique prefixed IDs for consentWithdrawals
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the consent withdrawal table
+     */
+    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;
+    }>;
+    /**
+     * Field definitions for the consent withdrawal table
+     */
+    fields: {
+        /**
+         * Reference to the consent that was withdrawn
+         */
+        consentId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * Reference to the subject who withdrew consent
+         */
+        subjectId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * Reason provided for withdrawing consent
+         */
+        withdrawalReason: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Method by which consent was withdrawn
+         * Common values: 'subject-initiated', 'automatic-expiry', 'admin'
+         */
+        withdrawalMethod: {
+            type: string;
+            defaultValue: () => string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * IP address from which the consentWithdrawal was initiated
+         */
+        ipAddress: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Subject agent (browser/device) from which the consentWithdrawal was initiated
+         */
+        userAgent: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Additional metadata about the consentWithdrawal
+         */
+        metadata: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the consentWithdrawal record was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Add unique constraint to ensure a consent can only be withdrawn once
+     * (If this constraint is not desired, it can be disabled in options)
+     */
+    uniqueConstraints: {
+        name: string;
+        fields: string[];
+    }[];
+    /**
+     * Add indexes for better query performance
+     */
+    indexes: {
+        name: string;
+        fields: string[];
+    }[];
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Withdrawal table needs to be created after the consent and subject tables it references
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

package/dist/db/schema/consent-withdrawal/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-withdrawal/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,WAAW,EACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAOvC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;;;;;QAWH;;WAEG;;;;;;;;;;QAWH;;WAEG;;;;;;QASH;;;WAGG;;;;;;;QAUH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;;IAeJ;;;OAGG;;;;;IAWH;;OAEG;;;;;IAYH;;;OAGG;;EAGJ"}

package/dist/db/schema/consent-withdrawal/types.d.ts

@@ -0,0 +1,28 @@
+import type { BaseEntityConfig } from '../types';
+/**
+ * Withdrawal entity configuration
+ * @default entityName: "consentWithdrawal", entityPrefix: "wdr"
+ */
+export interface ConsentWithdrawalEntityConfig extends BaseEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        consentId?: string;
+        revokedAt?: string;
+        revocationReason?: string;
+        method?: string;
+        actor?: string;
+        metadata?: string;
+        createdAt?: string;
+    };
+    /**
+     * Prevent multiple consentWithdrawals for the same consent
+     *
+     * If true, a subject can only have one consentWithdrawal record per consent,
+     * preventing multiple revocation records for the same consent.
+     * This helps maintain data integrity and clearer consent history.
+     *
+     * @default false
+     */
+    preventMultipleWithdrawals?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/db/schema/consent-withdrawal/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-withdrawal/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,6BAA8B,SAAQ,gBAAgB;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IAEF;;;;;;;;OAQG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACrC"}