@c15t/backend 1.8.0 → 2.0.0-rc.1

package/dist/schema/consent-policy/registry.d.ts

@@ -1,200 +0,0 @@
-import type { GenericEndpointContext, RegistryContext } from '../../pkgs/types';
-import type { ConsentPolicy, PolicyType } from './schema';
-/**
- * Creates and returns a set of consent policy-related adapter methods to interact with the database.
- * These methods provide a consistent interface for creating, finding, and updating
- * consent policy records while applying hooks and enforcing data validation rules.
- *
- * The returned registry object contains methods for common operations on consent policies,
- * including creation, retrieval, and conditional creation. All methods validate their
- * inputs and outputs according to the schema configuration.
- *
- * @param params - Registry context parameters
- * @param params.adapter - The database adapter used for direct database operations
- * @param params.ctx - Additional context properties containing hooks and options
- * @returns An object containing type-safe consent policy operations
- *
- * @example
- * ```typescript
- * const registry = policyRegistry({
- *   adapter: databaseAdapter,
- *   hooks: customHooks,
- *   options: validationOptions
- * });
- *
- * // Use the registry methods
- * const policy = await registry.findOrCreatePolicy('privacy');
- * ```
- *
- * @see {@link RegistryContext} For details on the context parameters
- * @see {@link ConsentPolicy} For the structure of policy objects
- */
-export declare function policyRegistry({ adapter, ...ctx }: RegistryContext): {
-    /**
-     * Creates a new consent policy record in the database.
-     * Automatically sets creation timestamp and applies any
-     * configured hooks during the creation process.
-     *
-     * This method validates the provided policy data, assigns a creation timestamp,
-     * and stores it in the database. It uses the configured hooks system to allow
-     * for customization of the creation process.
-     *
-     * @param policy - Policy data to create (without id and timestamp)
-     * @param context - Optional endpoint context for hooks execution
-     * @returns Promise resolving to the created policy with all fields populated
-     * @throws {Error} When the creation operation fails or returns null
-     * @throws May also throw errors if hooks prevent creation or if database operations fail
-     *
-     * @example
-     * ```ts
-     * const newPolicy = await policyRegistry.createConsentPolicy({
-     *   version: '1.0.0',
-     *   type: 'privacy',
-     *   name: 'Privacy Policy',
-     *   effectiveDate: new Date(),
-     *   content: 'Full policy text...',
-     *   contentHash: 'sha256-hash-of-content',
-     *   isActive: true,
-     *   updatedAt: new Date(),
-     *   expirationDate: null
-     * });
-     * ```
-     *
-     * @see {@link ConsentPolicy} For the structure of the policy object
-     * @see {@link GenericEndpointContext} For details on the context object
-     */
-    createConsentPolicy: (policy: Omit<ConsentPolicy, "id" | "createdAt"> & Partial<ConsentPolicy>, context?: GenericEndpointContext) => Promise<{
-        id: string;
-        version: string;
-        type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
-        name: string;
-        effectiveDate: Date;
-        content: string;
-        contentHash: string;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        expirationDate?: Date | null | undefined;
-    }>;
-    /**
-     * Retrieves consent policies from the database based on provided filter parameters.
-     *
-     * This method queries the database for consent policies matching the specified criteria.
-     * By default, only active policies are returned unless specifically requested otherwise.
-     * Results are sorted by effective date in descending order (newest first).
-     *
-     * @param params - Optional parameters to filter the policies
-     * @param params.domainId - Optional domain identifier to filter policies by domain
-     * @param params.version - Optional version string to filter policies by specific version
-     * @param params.includeInactive - When true, includes inactive policies in the results
-     * @returns Promise resolving to an array of validated consent policy objects
-     *
-     * @example
-     * ```ts
-     * // Get all active policies
-     * const activePolicies = await policyRegistry.findPolicies();
-     *
-     * // Get all policies including inactive ones
-     * const allPolicies = await policyRegistry.findPolicies({ includeInactive: true });
-     *
-     * // Get active policies for a specific version
-     * const specificVersionPolicies = await policyRegistry.findPolicies({
-     *   version: '2.0.0'
-     * });
-     * ```
-     *
-     * @see {@link ConsentPolicy} For the structure of returned policy objects
-     */
-    findPolicies: (params?: {
-        domainId?: string;
-        version?: string;
-        includeInactive?: boolean;
-    }) => Promise<{
-        id: string;
-        version: string;
-        type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
-        name: string;
-        effectiveDate: Date;
-        content: string;
-        contentHash: string;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        expirationDate?: Date | null | undefined;
-    }[]>;
-    /**
-     * Finds a consent policy by its unique ID.
-     * Returns the policy with processed output fields according to the schema configuration.
-     *
-     * This method queries the database for a single consent policy that matches the provided ID.
-     * The resulting policy is validated against the schema before being returned.
-     *
-     * @param policyId - The unique identifier of the policy to find
-     * @returns Promise resolving to the validated policy object if found, null otherwise
-     *
-     * @example
-     * ```ts
-     * // Find a policy by ID
-     * const policy = await policyRegistry.findConsentPolicyById('policy-123');
-     * if (policy) {
-     *   console.log(`Found policy: ${policy.name}, version ${policy.version}`);
-     * } else {
-     *   console.log('Policy not found');
-     * }
-     * ```
-     *
-     * @see {@link ConsentPolicy} For the structure of the returned policy object
-     */
-    findConsentPolicyById: (policyId: string) => Promise<{
-        id: string;
-        version: string;
-        type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
-        name: string;
-        effectiveDate: Date;
-        content: string;
-        contentHash: string;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        expirationDate?: Date | null | undefined;
-    } | null>;
-    /**
-     * Finds the latest active policy or creates a new one if none exists.
-     * Uses a database transaction to prevent race conditions in multi-threaded environments.
-     *
-     * If multiple active policies with the same type exist, returns the most recent one
-     * based on effectiveDate. When creating a new policy, it assigns version '1.0.0'
-     * and generates placeholder content with a SHA-256 hash.
-     *
-     * @param type - The type of the policy to find/create (e.g., 'privacy', 'terms')
-     * @returns Promise resolving to the found or newly created policy object
-     * @throws {Error} If the database transaction fails to complete
-     *
-     * @example
-     * ```ts
-     * // Find or create a privacy policy
-     * const privacyPolicy = await policyRegistry.findOrCreatePolicy('privacy');
-     *
-     * // Find or create a terms of service policy
-     * const termsPolicy = await policyRegistry.findOrCreatePolicy('terms');
-     * ```
-     *
-     * @see {@link PolicyType} For the available policy types
-     * @see {@link ConsentPolicy} For the structure of the returned policy object
-     * @see {@link generatePolicyPlaceholder} For details on how placeholder content is generated
-     */
-    findOrCreatePolicy: (type: PolicyType) => Promise<{
-        id: string;
-        version: string;
-        type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
-        name: string;
-        effectiveDate: Date;
-        content: string;
-        contentHash: string;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        expirationDate?: Date | null | undefined;
-    }>;
-};
-//# sourceMappingURL=registry.d.ts.map

package/dist/schema/consent-policy/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/schema/consent-policy/registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE5E,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAgD1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;kCAEM,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,YAC9D,sBAAsB;;;;;;;;;;;;;IAwBjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;4BAEM;QACP,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC1B;;;;;;;;;;;;;IAuCF;;;;;;;;;;;;;;;;;;;;;;OAsBG;sCACqC,MAAM;;;;;;;;;;;;;IAe9C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;+BAC8B,UAAU;;;;;;;;;;;;;EAuE5C"}

package/dist/schema/consent-policy/schema.d.ts

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-export declare const PolicyTypeSchema: z.ZodEnum<{
-    cookie_banner: "cookie_banner";
-    privacy_policy: "privacy_policy";
-    dpa: "dpa";
-    terms_and_conditions: "terms_and_conditions";
-    marketing_communications: "marketing_communications";
-    age_verification: "age_verification";
-    other: "other";
-}>;
-export type PolicyType = z.infer<typeof PolicyTypeSchema>;
-/**
- * Zod schema for validating consent policy entities.
- *
- * This defines the structure and validation rules for consent policy records:
- * - Required fields: version, name, effectiveDate, content, contentHash
- * - Optional fields: expirationDate
- * - Default value of true for isActive
- * - Default current date/time for creation and update timestamps
- *
- * @example
- * ```typescript
- * const policyData = {
- *   id: 'pol_w5qufx2a66m7xkn3ty',
- *   version: '1.0.0',
- *   name: 'Privacy Policy 2023',
- *   effectiveDate: new Date(),
- *   content: 'Full policy text...',
- *   contentHash: 'sha256-hash-of-content'
- * };
- *
- * // Validate and parse the policy data
- * const validPolicy = consentPolicySchema.parse(policyData);
- * ```
- */
-export declare const consentPolicySchema: z.ZodObject<{
-    id: z.ZodString;
-    version: z.ZodString;
-    type: z.ZodEnum<{
-        cookie_banner: "cookie_banner";
-        privacy_policy: "privacy_policy";
-        dpa: "dpa";
-        terms_and_conditions: "terms_and_conditions";
-        marketing_communications: "marketing_communications";
-        age_verification: "age_verification";
-        other: "other";
-    }>;
-    name: z.ZodString;
-    effectiveDate: z.ZodDate;
-    expirationDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
-    content: z.ZodString;
-    contentHash: z.ZodString;
-    isActive: z.ZodPrefault<z.ZodBoolean>;
-    createdAt: z.ZodPrefault<z.ZodDate>;
-    updatedAt: z.ZodPrefault<z.ZodDate>;
-}, z.core.$strip>;
-/**
- * Type definition for ConsentPolicy
- *
- * This type represents the structure of a consent policy record
- * as defined by the consentPolicySchema. It includes all fields
- * that are part of the consent policy entity.
- */
-export type ConsentPolicy = z.infer<typeof consentPolicySchema>;
-//# sourceMappingURL=schema.d.ts.map

package/dist/schema/consent-policy/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/schema/consent-policy/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;;;;;EAQ3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAY9B,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/schema/consent-policy/table.d.ts

@@ -1,142 +0,0 @@
-import type { Field } from '../../pkgs/data-model';
-import type { C15TOptions } from '../../types';
-/**
- * Generates the database table configuration for the consent policy entity.
- *
- * This function creates a schema definition that includes all standard consent policy 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 policy table customizations
- * @param policyFields - Additional fields from plugins to include in the policy table
- * @returns A complete table schema definition with fields, model name, and metadata
- *
- * @example
- * ```typescript
- * const policyTableSchema = getConsentPolicyTable(c15tOptions);
- * // Use the schema for migrations or data access
- * const migrationPlans = generateMigrations(policyTableSchema);
- * ```
- */
-export declare function getConsentPolicyTable(options: C15TOptions, policyFields?: Record<string, Field>): {
-    /**
-     * The name of the policy table in the database, configurable through options
-     */
-    entityName: string;
-    /**
-     * The ID prefix for the consent policy table
-     * Used to generate unique prefixed IDs for consent policies
-     */
-    entityPrefix: string;
-    /**
-     * The schema for the consent policy table
-     */
-    schema: import("zod").ZodObject<{
-        id: import("zod").ZodString;
-        version: import("zod").ZodString;
-        type: import("zod").ZodEnum<{
-            cookie_banner: "cookie_banner";
-            privacy_policy: "privacy_policy";
-            dpa: "dpa";
-            terms_and_conditions: "terms_and_conditions";
-            marketing_communications: "marketing_communications";
-            age_verification: "age_verification";
-            other: "other";
-        }>;
-        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").ZodPrefault<import("zod").ZodBoolean>;
-        createdAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-        updatedAt: import("zod").ZodPrefault<import("zod").ZodDate>;
-    }, import("zod/v4/core").$strip>;
-    /**
-     * Field definitions for the consent policy table
-     */
-    fields: {
-        /**
-         * Version identifier for the policy (e.g., "1.0.0")
-         */
-        version: {
-            type: string;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * Type of the policy
-         */
-        type: {
-            type: string;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * Human-readable name of the policy
-         */
-        name: {
-            type: string;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * Date when the policy becomes effective
-         */
-        effectiveDate: {
-            type: string;
-            required: boolean;
-            fieldName: string | Date;
-        };
-        /**
-         * Optional date when the policy expires
-         */
-        expirationDate: {
-            type: string;
-            required: boolean;
-            fieldName: string | Date;
-        };
-        /**
-         * Full content of the policy document
-         */
-        content: {
-            type: string;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * Hash of the content for integrity validation
-         */
-        contentHash: {
-            type: string;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * Whether this policy is currently active
-         * Default: true
-         */
-        isActive: {
-            type: string;
-            defaultValue: boolean;
-            required: boolean;
-            fieldName: string;
-        };
-        /**
-         * When the policy 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)
-     * Policy table needs to be created before tables that reference it (like consent)
-     */
-    order: number;
-};
-//# sourceMappingURL=table.d.ts.map

package/dist/schema/consent-policy/table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../src/schema/consent-policy/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,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;IAKnC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAQH;;WAEG;;;;;;QAQH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;;IAeJ;;;OAGG;;EAGJ"}

package/dist/schema/consent-policy/types.d.ts

@@ -1,29 +0,0 @@
-import type { BaseEntityConfig } from '../types';
-/**
- * Consent policy entity configuration
- * @default entityName: "consentPolicy", entityPrefix: "pol"
- */
-export interface ConsentPolicyEntityConfig extends BaseEntityConfig {
-    fields?: Record<string, string> & {
-        id?: string;
-        version?: string;
-        name?: string;
-        type?: string;
-        /**
-         * ISO format date string (e.g., "2024-04-15T00:00:00Z")
-         */
-        effectiveDate?: Date;
-        /**
-         * ISO format date string (e.g., "2024-04-15T00:00:00Z")
-         */
-        expirationDate?: Date;
-        content?: string;
-        contentHash?: string;
-        isActive?: string;
-        /**
-         * ISO format date string (e.g., "2024-04-15T00:00:00Z")
-         */
-        createdAt?: string;
-    };
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/schema/consent-policy/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/consent-policy/types.ts"],"names":[],"mappings":"AAAA,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,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd;;WAEG;QACH,aAAa,CAAC,EAAE,IAAI,CAAC;QACrB;;WAEG;QACH,cAAc,CAAC,EAAE,IAAI,CAAC;QACtB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB;;WAEG;QACH,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACF"}

package/dist/schema/consent-purpose/index.d.ts

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

package/dist/schema/consent-purpose/index.d.ts.map

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

package/dist/schema/consent-purpose/registry.d.ts

@@ -1,138 +0,0 @@
-import type { GenericEndpointContext, RegistryContext } from '../../pkgs/types';
-import type { ConsentPurpose } from './schema';
-/**
- * Creates and returns a set of consent purpose adapter methods to interact with the database.
- * These methods provide a consistent interface for creating and finding
- * consent purpose records while applying hooks and enforcing data validation rules.
- *
- * The consent purpose registry manages purpose definitions that describe specific
- * data processing activities for which consent may be given. Each purpose has a unique
- * code, name, description, and essential status flag indicating whether it's required
- * for core system functionality.
- *
- * @param params - Registry context parameters
- * @param params.adapter - The database adapter used for direct database operations
- * @param params.ctx - Additional context properties containing hooks and options
- * @returns An object containing type-safe consent purpose operations
- *
- * @example
- * ```ts
- * const registry = consentPurposeRegistry({
- *   adapter: databaseAdapter,
- *   hooks: customHooks,
- *   options: validationOptions
- * });
- *
- * // Create a marketing purpose
- * const marketingPurpose = await registry.createConsentPurpose({
- *   code: 'marketing',
- *   name: 'Marketing Communications',
- *   description: 'Allow us to send you promotional materials and offers',
- *   isEssential: false
- * });
- * ```
- *
- * @see {@link RegistryContext} For details on the context parameters
- * @see {@link ConsentPurpose} For the structure of consent purpose objects
- */
-export declare function consentPurposeRegistry({ adapter, ...ctx }: RegistryContext): {
-    /**
-     * Creates a new consent purpose record in the database.
-     *
-     * This method creates a purpose definition that subjects can consent to.
-     * Purposes represent specific data processing activities (such as marketing,
-     * analytics, or personalization) that require user consent. The method
-     * automatically sets creation and update timestamps and applies any
-     * configured hooks during the creation process.
-     *
-     * @param consentPurpose - ConsentPurpose data to create (without id and timestamps)
-     * @param consentPurpose.code - Unique code identifying the purpose (e.g., 'marketing')
-     * @param consentPurpose.name - Human-readable name for the purpose
-     * @param consentPurpose.description - Detailed explanation of what the purpose entails
-     * @param consentPurpose.isEssential - Whether this purpose is required for core functionality
-     * @param context - Optional endpoint context for hooks execution
-     * @returns Promise resolving to the created purpose with all fields populated
-     * @throws {Error} When the creation operation fails or returns null
-     * @throws May also throw errors if hooks prevent creation or if validation fails
-     *
-     * @example
-     * ```ts
-     * // Create an analytics purpose
-     * const analyticsPurpose = await registry.createConsentPurpose({
-     *   code: 'analytics',
-     *   name: 'Usage Analytics',
-     *   description: 'Collect anonymous usage data to improve our services',
-     *   isEssential: false,
-     *   metadata: {
-     *     category: 'Tracking',
-     *     dataRetention: '90 days'
-     *   }
-     * });
-     *
-     * // Create an essential purpose
-     * const essentialPurpose = await registry.createConsentPurpose({
-     *   code: 'security',
-     *   name: 'Security & Fraud Prevention',
-     *   description: 'Process data necessary to protect against unauthorized access',
-     *   isEssential: true,
-     *   metadata: {
-     *     category: 'Core',
-     *     legalBasis: 'legitimate interest'
-     *   }
-     * });
-     * ```
-     *
-     * @see {@link ConsentPurpose} For the complete structure of consent purpose objects
-     * @see {@link GenericEndpointContext} For details on the context object
-     */
-    createConsentPurpose: (consentPurpose: Omit<ConsentPurpose, "id" | "createdAt" | "updatedAt"> & Partial<ConsentPurpose>, context?: GenericEndpointContext) => Promise<{
-        id: string;
-        code: string;
-        name: string;
-        description: string;
-        isEssential: boolean;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        dataCategory?: string | null | undefined;
-        legalBasis?: string | null | undefined;
-    }>;
-    /**
-     * Finds a consent purpose by its unique code.
-     *
-     * This method retrieves a single consent purpose that matches the provided code.
-     * The code serves as a unique identifier for purposes across the system.
-     * The resulting purpose is validated against the schema before being returned.
-     *
-     * @param code - The unique code of the purpose to find
-     * @returns Promise resolving to the validated purpose object if found, null otherwise
-     *
-     * @example
-     * ```ts
-     * // Find the marketing purpose
-     * const marketingPurpose = await registry.findConsentPurposeByCode('marketing');
-     * if (marketingPurpose) {
-     *   console.log(`Found purpose: ${marketingPurpose.name}`);
-     *   console.log(`Description: ${marketingPurpose.description}`);
-     *   console.log(`Essential: ${marketingPurpose.isEssential ? 'Yes' : 'No'}`);
-     * } else {
-     *   console.log('Purpose not found');
-     * }
-     * ```
-     *
-     * @see {@link ConsentPurpose} For the structure of the returned purpose object
-     */
-    findConsentPurposeByCode: (code: string) => Promise<{
-        id: string;
-        code: string;
-        name: string;
-        description: string;
-        isEssential: boolean;
-        isActive: boolean;
-        createdAt: Date;
-        updatedAt: Date;
-        dataCategory?: string | null | undefined;
-        legalBasis?: string | null | undefined;
-    } | null>;
-};
-//# sourceMappingURL=registry.d.ts.map

package/dist/schema/consent-purpose/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/schema/consent-purpose/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;2CAEc,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC,GACrE,OAAO,CAAC,cAAc,CAAC,YACd,sBAAsB;;;;;;;;;;;;IA8BjC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;qCACoC,MAAM;;;;;;;;;;;;EAe9C"}

package/dist/schema/consent-purpose/schema.d.ts

@@ -1,57 +0,0 @@
-import { z } from 'zod';
-/**
- * Zod schema for validating consent consentPurpose entities.
- *
- * This defines the structure and validation rules for consent consentPurpose records:
- * - Required fields: code, name, description
- * - Default value of false for isEssential
- * - Default value of true for isActive
- * - Optional fields for dataCategory and legalBasis
- * - Default current date/time for creation and update timestamps
- *
- * @example
- * ```typescript
- * const purposeData = {
- *   id: 'pur_e8zyhgozr3im7xj59it',
- *   code: 'marketing',
- *   name: 'Marketing Communications',
- *   description: 'Allow us to send you marketing materials',
- *   isEssential: false
- * };
- *
- * // Validate and parse the consentPurpose data
- * const validPurpose = purposeSchema.parse(purposeData);
- *
- * // Example with missing fields (defaults will be applied)
- * const minimalPurposeData = {
- *   id: 'pur_e8zyhgozr3im7xj59it',
- *   code: 'marketing',
- *   name: 'Marketing Communications',
- *   description: 'Allow us to send you marketing materials',
- * };
- *
- * // isEssential will default to false, isActive to true, etc.
- * const purposeWithDefaults = purposeSchema.parse(minimalPurposeData);
- * ```
- */
-export declare const purposeSchema: z.ZodObject<{
-    id: z.ZodString;
-    code: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodString;
-    isEssential: z.ZodPrefault<z.ZodBoolean>;
-    dataCategory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    legalBasis: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    isActive: z.ZodPrefault<z.ZodBoolean>;
-    createdAt: z.ZodPrefault<z.ZodDate>;
-    updatedAt: z.ZodPrefault<z.ZodDate>;
-}, z.core.$strip>;
-/**
- * Type definition for ConsentPurpose
- *
- * This type represents the structure of a consent consentPurpose record
- * as defined by the purposeSchema. It includes all fields
- * that are part of the consent consentPurpose entity.
- */
-export type ConsentPurpose = z.infer<typeof purposeSchema>;
-//# sourceMappingURL=schema.d.ts.map

package/dist/schema/consent-purpose/schema.d.ts.map

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