@c15t/backend 0.0.1-rc.10

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/db/schema/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAgB3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDpD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAAC,SAAS,SAAS,MAAM,YAAY,IAClE,eAAe,CAAC,SAAS,CAAC,CAAC;AAE5B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,SAAS,SAAS,MAAM,YAAY,IAAI,IAAI,CACzE,eAAe,CAAC,SAAS,CAAC,EAC1B,IAAI,GAAG,WAAW,GAAG,WAAW,CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,SAAS,MAAM,YAAY,EACxE,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,WAAW,GAClB,kBAAkB,CAAC,SAAS,CAAC,CAU/B"}

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

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

package/dist/db/schema/domain/registry.d.ts

@@ -0,0 +1,169 @@
+import type { GenericEndpointContext, RegistryContext } from '../../../types';
+import type { Domain } from './schema';
+export interface FindDomainParams {
+    name?: string;
+    includeInactive?: boolean;
+}
+/**
+ * Creates and returns a set of domain-related adapter methods to interact with the database.
+ * These methods provide a consistent interface for creating, finding, and updating
+ * domain 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 domain operations
+ *
+ * @example
+ * ```typescript
+ * const domainAdapter = createDomainAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   updateWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new domain
+ * const domain = await domainAdapter.createDomain({
+ *   name: 'example.com',
+ *   description: 'Example company website',
+ *   isVerified: true
+ * });
+ * ```
+ */
+export declare function domainRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new domain record in the database.
+     * Automatically sets creation timestamp and applies any
+     * configured hooks during the creation process.
+     *
+     * @param domain - Domain data to create (without id and timestamp)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created domain with all fields populated
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createDomain: (domain: Omit<Domain, "id" | "createdAt" | "updatedAt"> & Partial<Domain>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        allowedOrigins: string[];
+        isVerified: boolean;
+        description?: string | undefined;
+    }>;
+    /**
+     * Finds an existing domain or creates a new one if needed.
+     *
+     * @param name - The domain name to find or create
+     * @param context - Optional endpoint context for hooks
+     * @returns The existing or newly created domain
+     * @throws APIError if domain creation fails
+     */
+    findOrCreateDomain: (name: string, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        allowedOrigins: string[];
+        isVerified: boolean;
+        description?: string | undefined;
+    }>;
+    /**
+     * Finds all domains, optionally including inactive ones.
+     * Returns domains with processed output fields according to the schema configuration.
+     *
+     * @param params - Optional parameters to filter the results
+     * @returns Array of domains matching the criteria
+     */
+    findDomains: (params?: FindDomainParams) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        allowedOrigins: string[];
+        isVerified: boolean;
+        description?: string | undefined;
+    }[]>;
+    /**
+     * Finds a domain by its name.
+     * Returns the domain with processed output fields according to the schema configuration.
+     *
+     * @param name - The domain name to search for
+     * @returns The domain object if found, null otherwise
+     */
+    findDomain: (name: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        allowedOrigins: string[];
+        isVerified: boolean;
+        description?: string | undefined;
+    } | null>;
+    /**
+     * Finds a domain by its unique ID.
+     * Returns the domain with processed output fields according to the schema configuration.
+     *
+     * @param domainId - The unique identifier of the domain
+     * @returns The domain object if found, null otherwise
+     */
+    findDomainById: (domainId: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        allowedOrigins: string[];
+        isVerified: boolean;
+        description?: string | undefined;
+    } | null>;
+    /**
+     * Finds a domain by its name.
+     * Returns the domain with processed output fields according to the schema configuration.
+     *
+     * @param name - The domain name to search for
+     * @returns The domain object if found, null otherwise
+     */
+    findDomainByName: (name: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        allowedOrigins: string[];
+        isVerified: boolean;
+        description?: string | undefined;
+    } | null>;
+    /**
+     * Updates an existing domain record by ID.
+     * Applies any configured hooks during the update process and
+     * processes the output according to schema configuration.
+     *
+     * @param domainId - The unique identifier of the domain to update
+     * @param data - The fields to update on the domain record
+     * @param context - Optional endpoint context for hooks
+     * @returns The updated domain if successful, null if not found or hooks prevented update
+     */
+    updateDomain: (domainId: string, data: Partial<Domain>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        allowedOrigins: string[];
+        isVerified: boolean;
+        description?: string | undefined;
+    } | null>;
+    /**
+     * Verifies if a domain exists and is active.
+     * Useful for checking domain validity during API requests.
+     *
+     * @param domainName - The domain name to verify
+     * @returns True if the domain exists and is active, false otherwise
+     */
+    verifyDomain: (domainName: string) => Promise<boolean>;
+};
+//# sourceMappingURL=registry.d.ts.map

package/dist/db/schema/domain/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/domain/registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,MAAM,WAAW,gBAAgB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGjE;;;;;;;;;OASG;2BAEM,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,YAC9D,sBAAsB;;;;;;;;;;IAoBjC;;;;;;;OAOG;+BAEI,MAAM,YACF,sBAAsB;;;;;;;;;;IA8BjC;;;;;;OAMG;2BACyB,gBAAgB;;;;;;;;;;IA+B5C;;;;;;OAMG;uBACsB,MAAM;;;;;;;;;;IAQ/B;;;;;;OAMG;+BAC8B,MAAM;;;;;;;;;;IAevC;;;;;;OAMG;6BAC4B,MAAM;;;;;;;;;;IAerC;;;;;;;;;OASG;6BAEQ,MAAM,QACV,OAAO,CAAC,MAAM,CAAC,YACX,sBAAsB;;;;;;;;;;IAsBjC;;;;;;OAMG;+BAC8B,MAAM;EAmBxC"}

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

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating domain entities.
+ *
+ * This defines the structure and validation rules for domain records:
+ * - Required fields: name
+ * - Optional fields: description, allowedOrigins
+ * - Default value of true for isActive and isVerified
+ * - Default current date/time for creation timestamp
+ *
+ * @example
+ * ```typescript
+ * const domainData = {
+ *   id: 'dom_x1pftyoufsm7xgo1kv',
+ *   name: 'example.com',
+ *   description: 'Company website',
+ *   allowedOrigins: ['https://app.example.com', 'https://admin.example.com']
+ * };
+ *
+ * // Validate and parse the domain data
+ * const validDomain = domainSchema.parse(domainData);
+ * ```
+ */
+export declare const domainSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    allowedOrigins: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    isVerified: z.ZodDefault<z.ZodBoolean>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.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;
+}>;
+/**
+ * Type definition for Domain
+ *
+ * This type represents the structure of a domain record
+ * as defined by the domainSchema. It includes all fields
+ * that are part of the domain entity.
+ */
+export type Domain = z.infer<typeof domainSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/db/schema/domain/schema.d.ts.map

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

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

@@ -0,0 +1,140 @@
+import type { Field } from '../../core/fields';
+import type { C15TOptions } from '../../../types';
+/**
+ * Generates the database table configuration for the domain entity.
+ *
+ * This function creates a schema definition that includes all standard domain 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 domain table customizations
+ * @param domainFields - Additional fields from plugins to include in the domain table
+ * @returns A complete table schema definition with fields, model name, and metadata
+ *
+ * @example
+ * ```typescript
+ * const domainTableSchema = getDomainTable(c15tOptions);
+ * // Use the schema for migrations or data access
+ * const migrationPlans = generateMigrations(domainTableSchema);
+ * ```
+ */
+export declare function getDomainTable(options: C15TOptions, domainFields?: Record<string, Field>): {
+    /**
+     * The name of the domain table in the database, configurable through options
+     */
+    entityName: string;
+    /**
+     * The ID prefix for the domain table
+     * Used to generate unique prefixed IDs for domains
+     */
+    entityPrefix: string;
+    /**
+     * The schema for the domain table
+     */
+    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;
+    }>;
+    /**
+     * Field definitions for the domain table
+     */
+    fields: {
+        /**
+         * Domain name (e.g., "example.com")
+         * This is the primary identifier for the domain in addition to its ID
+         */
+        name: {
+            type: string;
+            required: boolean;
+            unique: boolean;
+            fieldName: string;
+        };
+        /**
+         * Optional human-readable description of the domain
+         */
+        description: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * List of additional origins that are allowed to access resources for this domain
+         * Stored as a JSON array of strings
+         */
+        allowedOrigins: {
+            type: string;
+            defaultValue: () => never[];
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Whether domain ownership has been verified
+         * Default: true
+         */
+        isVerified: {
+            type: string;
+            defaultValue: boolean;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * Whether this domain is currently active
+         * Default: true
+         */
+        isActive: {
+            type: string;
+            defaultValue: boolean;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the domain record was created
+         * Automatically set to current time by default
+         */
+        createdAt: {
+            type: string;
+            defaultValue: () => Date;
+            required: boolean;
+            fieldName: string;
+        };
+        /**
+         * When the domain record was last updated
+         * Optional, set during updates
+         */
+        updatedAt: {
+            type: string;
+            required: boolean;
+            fieldName: string;
+        };
+    };
+    /**
+     * Execution order during migrations (lower numbers run first)
+     * Domain table needs to be created before tables that reference it
+     */
+    order: number;
+};
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/domain/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,cAAc,CAC7B,OAAO,EAAE,WAAW,EACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAKnC;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;QAEF;;;WAGG;;;;;;;QAQH;;WAEG;;;;;;QAOH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;QAQH;;;WAGG;;;;;;;IAcJ;;;OAGG;;EAGJ"}

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

@@ -0,0 +1,27 @@
+import type { ActiveEntityConfig } from '../types';
+/**
+ * Domain entity configuration
+ * @default entityName: "domain", entityPrefix: "dom"
+ */
+export interface DomainEntityConfig extends ActiveEntityConfig {
+    fields?: Record<string, string> & {
+        id?: string;
+        domain: string;
+        /**
+         * Indicates if the domain is a pattern (e.g., "true"/"false")
+         * When true, the domain string will be interpreted as a pattern
+         */
+        isPattern?: string;
+        /**
+         * The type of pattern matching to apply
+         * Valid values: "regex", "wildcard", "prefix", "suffix", "exact"
+         */
+        patternType?: string;
+        parentDomainId?: string;
+        description?: string;
+        isActive?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/domain/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QACjC,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;QACf;;;WAGG;QACH,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACF"}

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

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

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

@@ -0,0 +1,114 @@
+import type { GenericEndpointContext, RegistryContext } from '../../../types';
+import type { GeoLocation } from './schema';
+/**
+ * Creates and returns a set of 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 geo-location operations
+ *
+ * @example
+ * ```typescript
+ * const locationAdapter = createGeoLocationAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new geo-location record
+ * const location = await locationAdapter.createGeoLocation({
+ *   countryCode: 'US',
+ *   countryName: 'United States',
+ *   regionCode: 'CA',
+ *   regionName: 'California',
+ *   regulatoryZones: ['CCPA', 'CPRA']
+ * });
+ * ```
+ */
+export declare function geoLocationRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new geo-location record in the database.
+     * Automatically sets creation timestamp and applies any
+     * configured hooks during the creation process.
+     *
+     * @param location - 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
+     */
+    createGeoLocation: (location: Omit<GeoLocation, "id" | "createdAt"> & Partial<GeoLocation>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        createdAt: Date;
+        countryCode: string;
+        countryName: string;
+        regionCode?: string | undefined;
+        regionName?: string | undefined;
+        regulatoryZones?: ("GDPR" | "CCPA" | "CPRA" | "LGPD" | "PIPEDA")[] | undefined;
+    }>;
+    /**
+     * Finds all geo-location records matching the given criteria.
+     * Returns geo-locations with processed output fields according to the schema configuration.
+     *
+     * @param filter - Optional filter parameters for the query
+     * @returns Array of geo-location records matching the criteria
+     */
+    findGeoLocations: (filter?: {
+        countryCode?: string;
+        regionCode?: 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 locationId - The unique identifier of the geo-location record
+     * @returns The geo-location object if found, null otherwise
+     */
+    findGeoLocationById: (locationId: 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>;
+    /**
+     * Finds geo-location records by country code.
+     * Returns geo-locations with processed output fields according to the schema configuration.
+     *
+     * @param countryCode - The country code to search for
+     * @returns Array of geo-location records for the specified country
+     */
+    findGeoLocationsByCountry: (countryCode: 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;
+    }[]>;
+};
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/geo-location/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAGtE;;;;;;;;;OASG;kCAEQ,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,YAC5D,sBAAsB;;;;;;;;;IAqBjC;;;;;;OAMG;gCAC+B;QACjC,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;KACpB;;;;;;;;;;;;;IA+BD;;;;;;OAMG;sCACqC,MAAM;;;;;;;;;;;;;IAe9C;;;;;;OAMG;6CAC4C,MAAM;;;;;;;;;;;;;EAoBtD"}

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating geo-location entities.
+ *
+ * This defines the structure and validation rules for geographic location records:
+ * - Required fields: countryCode, countryName
+ * - Optional fields: regionCode, regionName, regulatoryZones
+ * - Default current date/time for creation timestamp
+ *
+ * @example
+ * ```typescript
+ * const locationData = {
+ *   id: 'geo_x1pftyoufsm7xgo1kv',
+ *   countryCode: 'US',
+ *   countryName: 'United States',
+ *   regionCode: 'CA',
+ *   regionName: 'California',
+ *   regulatoryZones: ['CCPA', 'CPRA']
+ * };
+ *
+ * // Validate and parse the geo-location data
+ * const validLocation = geoLocationSchema.parse(locationData);
+ * ```
+ */
+export declare const geoLocationSchema: z.ZodObject<{
+    id: z.ZodString;
+    countryCode: z.ZodString;
+    countryName: z.ZodString;
+    regionCode: z.ZodOptional<z.ZodString>;
+    regionName: z.ZodOptional<z.ZodString>;
+    regulatoryZones: z.ZodOptional<z.ZodArray<z.ZodEnum<["GDPR", "CCPA", "CPRA", "LGPD", "PIPEDA"]>, "many">>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.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;
+}>;
+/**
+ * Type definition for GeoLocation
+ *
+ * This type represents the structure of a geo-location entity
+ * as defined by the geoLocationSchema. It includes all fields
+ * that are part of the geo-location entity.
+ */
+export type GeoLocation = z.infer<typeof geoLocationSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

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