@c15t/backend 0.0.1-rc.10

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

@@ -0,0 +1,245 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the consent entity.
+ *
+ * This function creates a schema definition that includes all standard consent 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 table customizations
+ * @param consentFields - Additional fields from plugins to include in the consent table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const consentTableSchema = getConsentTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(consentTableSchema);
+ * ```
+ */
+export declare function getConsentTable(options: C15TOptions, consentFields?: Record<string, Field>): {
+    /**
+     * The name of the consent table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the consent table
+     * Used to generate unique prefixed IDs for consents
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the consent table
+     */
+    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;
+    }>;
+    /**
+     * Field definitions for the consent table
+     */
+    fields: {
+        /**
+         * Reference to the subject who gave consent
+         */
+        subjectId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * Reference to the domain this consent applies to
+         */
+        domainId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * Array of consentPurpose IDs that this consent applies to
+         * Represents the many-to-many relationship between consent and purposes
+         */
+        purposeIds: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+                type: string;
+            };
+        };
+        /**
+         * Additional metadata about the consent
+         */
+        metadata: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Reference to the policy version that was accepted
+         */
+        policyId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * IP address when consent was given
+         */
+        ipAddress: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Subject agent information when consent was given
+         */
+        userAgent: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Status of the consent (active, expired, withdrawn)
+         * Default: 'active'
+         */
+        status: {
+            type: string;
+            defaultValue: () => string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Reason for consentWithdrawal, if consent was withdrawn
+         */
+        withdrawalReason: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the consent was given
+         * Automatically set to current time
+         */
+        givenAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the consent expires
+         * Calculated based on givenAt + expiresIn setting
+         */
+        validUntil: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            transform: {
+                input: (val: Date | undefined, data: Record<string, unknown>) => Date | undefined;
+            };
+        };
+        /**
+         * Whether the consent is active
+         * Default: true
+         */
+        isActive: {
+            type: string;
+            defaultValue: boolean;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Consent table needs to be created after the subject, domain, and policy tables it references
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent/table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,WAAW,EACpB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAUpC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;;;;;QAWH;;WAEG;;;;;;;;;;QAWH;;;WAGG;;;;;;;;;;;QAYH;;WAEG;;;;;;QAOH;;WAEG;;;;;;;;;;QAWH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;WAEG;;;;;;QAQH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;6BAMY,IAAI,GAAG,SAAS,QAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;QAoB9D;;;WAGG;;;;;;;;IAeJ;;;OAGG;;EAGJ"}

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

@@ -0,0 +1,37 @@
+/**
+ * Consent Entity Type Definitions
+ *
+ * This module contains type definitions specific to the consent entity.
+ */
+import type { BaseEntityConfig } from '../types';
+/**
+ * Consent entity configuration
+ * @default entityName: "consent", entityPrefix: "cns"
+ */
+export interface ConsentEntityConfig extends BaseEntityConfig {
+    /**
+     * Default expiration for consent in seconds
+     * @default 31536000 (1 year)
+     */
+    expiresIn?: number;
+    /**
+     * Time in seconds before refreshing consent data
+     * @default 86400 (24 hours)
+     */
+    updateAge?: number;
+    fields?: Record<string, string> & {
+        id?: string;
+        subjectId?: string;
+        domainId?: string;
+        purposeIds?: string;
+        metadata?: string;
+        policyId?: string;
+        ipAddress?: string;
+        userAgent?: string;
+        status?: string;
+        withdrawalReason?: string;
+        givenAt?: string;
+        validUntil?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC5D;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACF"}

package/dist/db/schema/consent-geo-location/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-geo-location/index.d.ts.map

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

package/dist/db/schema/consent-geo-location/registry.d.ts

@@ -0,0 +1,96 @@
+import type { GenericEndpointContext, RegistryContext } from '../../../types';
+import type { ConsentGeoLocation } from './schema';
+/**
+ * Creates and returns a set of consent geo-location-related adapter methods to interact with the database.
+ * These methods provide a consistent interface for creating and finding
+ * geo-location 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 geo-location operations
+ *
+ * @example
+ * ```typescript
+ * const geoLocationAdapter = createConsentGeoLocationAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new geo-location record
+ * const geoLocation = await geoLocationAdapter.createConsentGeoLocation({
+ *   consentId: 'cns_hadt8w7nngm7xmx2bn',
+ *   ip: '192.168.1.1',
+ *   country: 'US',
+ *   city: 'New York',
+ *   latitude: 40.7128,
+ *   longitude: -74.0060
+ * });
+ * ```
+ */
+export declare function consentGeoLocationRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new consent geo-location record in the database.
+     * Automatically sets creation timestamp and applies any
+     * configured hooks during the creation process.
+     *
+     * @param geoLocation - Geo-location data to create (without id and timestamp)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created geo-location record with all fields populated
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createConsentGeoLocation: (geoLocation: Omit<ConsentGeoLocation, "id" | "createdAt"> & Partial<ConsentGeoLocation>, context?: GenericEndpointContext) => Promise<{
+        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;
+    }>;
+    /**
+     * Finds geo-location records associated with a specific consent ID.
+     * Returns geo-locations with processed output fields according to the schema configuration.
+     *
+     * @param consentId - The ID of the consent record to find geo-locations for
+     * @returns Array of geo-location records associated with the consent
+     */
+    findConsentGeoLocationsByConsentId: (consentId: string) => Promise<{
+        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;
+    }[]>;
+    /**
+     * Finds a geo-location record by its unique ID.
+     * Returns the geo-location with processed output fields according to the schema configuration.
+     *
+     * @param geoLocationId - The unique identifier of the geo-location record
+     * @returns The geo-location object if found, null otherwise
+     */
+    findConsentGeoLocationById: (geoLocationId: string) => Promise<{
+        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;
+    } | null>;
+};
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-geo-location/registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,0BAA0B,CAAC,EAC1C,OAAO,EACP,GAAG,GAAG,EACN,EAAE,eAAe;IAIhB;;;;;;;;;OASG;4CAEW,IAAI,CAAC,kBAAkB,EAAE,IAAI,GAAG,WAAW,CAAC,GACxD,OAAO,CAAC,kBAAkB,CAAC,YAClB,sBAAsB;;;;;;;;;;;;;IAqBjC;;;;;;OAMG;oDACmD,MAAM;;;;;;;;;;;;;IAoB5D;;;;;;OAMG;gDAC+C,MAAM;;;;;;;;;;;;;EAezD"}

package/dist/db/schema/consent-geo-location/schema.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating consent geo-location entities.
+ *
+ * This defines the structure and validation rules for geo-location records:
+ * - Required fields: consentId, ip (IP address)
+ * - Optional fields: country, region, city, latitude, longitude, timezone
+ * - Default current date/time for creation and update timestamps
+ *
+ * @example
+ * ```typescript
+ * const geoLocationData = {
+ *   id: 'cgl_w5qufx2a66m7xkn3ty',
+ *   consentId: 'cns_hadt8w7nngm7xmx2bn',
+ *   ip: '192.168.1.1',
+ *   country: 'US',
+ *   city: 'New York',
+ *   latitude: 40.7128,
+ *   longitude: -74.0060
+ * };
+ *
+ * // Validate and parse the geo-location data
+ * const validGeoLocation = consentGeoLocationSchema.parse(geoLocationData);
+ * ```
+ */
+export declare const consentGeoLocationSchema: z.ZodObject<{
+    id: z.ZodString;
+    consentId: z.ZodString;
+    ip: z.ZodString;
+    country: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    latitude: z.ZodOptional<z.ZodNumber>;
+    longitude: z.ZodOptional<z.ZodNumber>;
+    timezone: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.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;
+}>;
+/**
+ * Type definition for ConsentGeoLocation
+ *
+ * This type represents the structure of a consent geo-location record
+ * as defined by the consentGeoLocationSchema. It includes all fields
+ * that are part of the consent geo-location entity.
+ */
+export type ConsentGeoLocation = z.infer<typeof consentGeoLocationSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/db/schema/consent-geo-location/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-geo-location/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAenC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/db/schema/consent-geo-location/table.d.ts

@@ -0,0 +1,167 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the consent geo-location entity.
+ *
+ * This function creates a schema definition that includes all standard geo-location 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 geo-location table customizations
+ * @param geoLocationFields - Additional fields from plugins to include in the geo-location table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const geoLocationTableSchema = getConsentGeoLocationTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(geoLocationTableSchema);
+ * ```
+ */
+export declare function getConsentGeoLocationTable(options: C15TOptions, geoLocationFields?: Record<string, Field>): {
+    /**
+     * The name of the geo-location table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the consent geo-location table
+     * Used to generate unique prefixed IDs for consent geo-locations
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the consent geo-location table
+     */
+    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;
+    }>;
+    /**
+     * Field definitions for the consent geo-location table
+     */
+    fields: {
+        /**
+         * Reference to the consent record this geo-location is associated with
+         */
+        consentId: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+            references: {
+                model: string;
+                field: string;
+            };
+        };
+        /**
+         * IP address from which the consent was given
+         */
+        ip: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Country code (e.g., 'US', 'DE', 'FR')
+         */
+        country: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Region or state (e.g., 'California', 'Bavaria')
+         */
+        region: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * City name (e.g., 'New York', 'Berlin')
+         */
+        city: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Latitude coordinate
+         */
+        latitude: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Longitude coordinate
+         */
+        longitude: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Timezone identifier (e.g., 'America/New_York', 'Europe/Berlin')
+         */
+        timezone: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the geo-location record was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Add indexes for better query performance
+     */
+    indexes: {
+        name: string;
+        fields: string[];
+    }[];
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Geo-location table needs to be created after the consent table it references
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-geo-location/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,0BAA0B,CACzC,OAAO,EAAE,WAAW,EACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAMxC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;WAEG;;;;;;;;;;QAWH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;;IAeJ;;OAEG;;;;;IAgBH;;;OAGG;;EAGJ"}

package/dist/db/schema/consent-geo-location/types.d.ts

@@ -0,0 +1,21 @@
+import type { BaseEntityConfig } from '../types';
+/**
+ * Consent geo location entity configuration
+ * @default entityName: "consentGeoLocation", entityPrefix: "cgl"
+ */
+export interface ConsentGeoLocationEntityConfig extends BaseEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        /**
+         * Indicates if the domain is a pattern (e.g., "true"/"false")
+         * When true, the domain string will be interpreted as a pattern
+         */
+        consentId?: string;
+        /**
+         * Foreign key to geo-location entity (should be indexed)
+         */
+        geoLocationId?: string;
+        createdAt?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/consent-geo-location/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;GAGG;AACH,MAAM,WAAW,8BAA+B,SAAQ,gBAAgB;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ;;;WAGG;QACH,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB;;WAEG;QACH,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACF"}

package/dist/db/schema/consent-policy/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-policy/index.d.ts.map

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