@c15t/backend 0.0.1-rc.10

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

@@ -0,0 +1,383 @@
+import type { z } from 'zod';
+export declare const schemas: {
+    readonly auditLog: z.ZodObject<{
+        id: z.ZodString;
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+        actionType: z.ZodString;
+        subjectId: z.ZodOptional<z.ZodString>;
+        ipAddress: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+        changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodDefault<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        createdAt: Date;
+        subjectId?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+        changes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        subjectId?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+        changes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        createdAt?: Date | undefined;
+    }>;
+    readonly consent: z.ZodObject<{
+        id: z.ZodString;
+        subjectId: z.ZodString;
+        domainId: z.ZodString;
+        purposeIds: z.ZodArray<z.ZodString, "many">;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        policyId: z.ZodOptional<z.ZodString>;
+        ipAddress: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<["active", "withdrawn", "expired"]>>;
+        withdrawalReason: z.ZodOptional<z.ZodString>;
+        givenAt: z.ZodDefault<z.ZodDate>;
+        validUntil: z.ZodOptional<z.ZodDate>;
+        isActive: z.ZodDefault<z.ZodBoolean>;
+        history: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            actionType: z.ZodEnum<["given", "withdrawn", "updated", "expired"]>;
+            timestamp: z.ZodDate;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            previousState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            newState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.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", z.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;
+    }>;
+    readonly consentGeoLocation: 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;
+    }>;
+    readonly consentPolicy: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        name: z.ZodString;
+        effectiveDate: z.ZodDate;
+        expirationDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        content: z.ZodString;
+        contentHash: z.ZodString;
+        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;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        expirationDate?: Date | null | undefined;
+    }, {
+        id: string;
+        version: string;
+        name: string;
+        effectiveDate: Date;
+        content: string;
+        contentHash: string;
+        createdAt?: Date | undefined;
+        isActive?: boolean | undefined;
+        updatedAt?: Date | undefined;
+        expirationDate?: Date | null | undefined;
+    }>;
+    readonly consentPurpose: z.ZodObject<{
+        id: z.ZodString;
+        code: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        isEssential: z.ZodDefault<z.ZodBoolean>;
+        dataCategory: z.ZodOptional<z.ZodString>;
+        legalBasis: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodDefault<z.ZodBoolean>;
+        createdAt: z.ZodDefault<z.ZodDate>;
+        updatedAt: z.ZodDefault<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        code: string;
+        createdAt: Date;
+        isActive: boolean;
+        updatedAt: Date;
+        name: string;
+        description: string;
+        isEssential: boolean;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    }, {
+        id: string;
+        code: string;
+        name: string;
+        description: string;
+        createdAt?: Date | undefined;
+        isActive?: boolean | undefined;
+        updatedAt?: Date | undefined;
+        isEssential?: boolean | undefined;
+        dataCategory?: string | undefined;
+        legalBasis?: string | undefined;
+    }>;
+    readonly consentPurposeJunction: z.ZodObject<{
+        id: z.ZodString;
+        consentId: z.ZodString;
+        consentPurposeId: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<["active", "withdrawn"]>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        createdAt: z.ZodDefault<z.ZodDate>;
+        updatedAt: z.ZodDefault<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "active" | "withdrawn";
+        createdAt: Date;
+        consentId: string;
+        updatedAt: Date;
+        consentPurposeId: string;
+        metadata?: Record<string, string | number | boolean> | undefined;
+    }, {
+        id: string;
+        consentId: string;
+        consentPurposeId: string;
+        status?: "active" | "withdrawn" | undefined;
+        metadata?: Record<string, string | number | boolean> | undefined;
+        createdAt?: Date | undefined;
+        updatedAt?: Date | undefined;
+    }>;
+    readonly consentRecord: 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;
+    }>;
+    readonly consentWithdrawal: 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;
+    }>;
+    readonly domain: 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;
+    }>;
+    readonly geoLocation: 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;
+    }>;
+    readonly subject: z.ZodObject<{
+        id: z.ZodString;
+        isIdentified: z.ZodDefault<z.ZodBoolean>;
+        externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        identityProvider: z.ZodOptional<z.ZodString>;
+        lastIpAddress: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodDefault<z.ZodDate>;
+        updatedAt: z.ZodDefault<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        isIdentified: boolean;
+        externalId?: string | null | undefined;
+        identityProvider?: string | undefined;
+        lastIpAddress?: string | undefined;
+    }, {
+        id: string;
+        createdAt?: Date | undefined;
+        updatedAt?: Date | undefined;
+        isIdentified?: boolean | undefined;
+        externalId?: string | null | undefined;
+        identityProvider?: string | undefined;
+        lastIpAddress?: string | undefined;
+    }>;
+};
+export type TableName = keyof typeof schemas;
+export type InferTableShape<T extends TableName> = z.infer<(typeof schemas)[T]>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/db/schema/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgB7B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYV,CAAC;AAGX,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,OAAO,CAAC;AAG7C,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC"}

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

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

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

@@ -0,0 +1,141 @@
+import type { GenericEndpointContext, RegistryContext } from '../../../types';
+import type { Subject } from './schema';
+/**
+ * Creates and returns a set of subject-related adapter methods to interact with the database.
+ *
+ * These methods provide a consistent interface for creating, finding, updating, and deleting
+ * subject 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 subject operations
+ *
+ * @example
+ * ```typescript
+ * const subjectAdapter = createSubjectAdapter(
+ *   databaseAdapter,
+ *   createWithHooks,
+ *   updateWithHooks,
+ *   c15tOptions
+ * );
+ *
+ * // Create a new subject
+ * const subject = await subjectAdapter.createSubject({
+ *   externalId: 'external-123',
+ *   identityProvider: 'auth0'
+ * });
+ * ```
+ */
+export declare function subjectRegistry({ adapter, ...ctx }: RegistryContext): {
+    /**
+     * Creates a new subject record in the database.
+     *
+     * Automatically sets creation and update timestamps and applies any
+     * configured hooks during the creation process.
+     *
+     * @param subject - Subject data to create (without id and timestamps)
+     * @param context - Optional endpoint context for hooks
+     * @returns The created subject with all fields populated
+     *
+     * @throws May throw an error if hooks prevent creation or if database operations fail
+     */
+    createSubject: (subject: Omit<Subject, "id" | "createdAt" | "updatedAt"> & Partial<Subject>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        isIdentified: boolean;
+        externalId?: string | null | undefined;
+        identityProvider?: string | undefined;
+        lastIpAddress?: string | undefined;
+    } | null>;
+    /**
+     * Finds an existing subject or creates a new one if needed.
+     * If both subjectId and externalSubjectId are provided, validates they match the same subject.
+     * Creates a new anonymous subject only if no identifiers are provided.
+     *
+     * @param params - Parameters for finding or creating the subject
+     * @returns The existing or newly created subject
+     * @throws APIError if subject validation fails or creation fails
+     */
+    findOrCreateSubject: ({ subjectId, externalSubjectId, ipAddress, context, }: {
+        subjectId?: string;
+        externalSubjectId?: string;
+        ipAddress?: string;
+        context?: GenericEndpointContext;
+    }) => Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        isIdentified: boolean;
+        externalId?: string | null | undefined;
+        identityProvider?: string | undefined;
+        lastIpAddress?: string | undefined;
+    } | null>;
+    /**
+     * Finds a subject by their unique ID.
+     *
+     * Returns the subject with processed output fields according to the schema configuration.
+     *
+     * @param subjectId - The unique identifier of the subject
+     * @returns The subject object if found, null otherwise
+     */
+    findSubjectById: (subjectId: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        isIdentified: boolean;
+        externalId?: string | null | undefined;
+        identityProvider?: string | undefined;
+        lastIpAddress?: string | undefined;
+    } | null>;
+    /**
+     * Finds a subject by their external ID.
+     *
+     * This is useful when integrating with external authentication systems
+     * where subjects are identified by a provider-specific ID.
+     *
+     * @param externalId - The external identifier of the subject
+     * @returns The subject object if found, null otherwise
+     */
+    findSubjectByExternalId: (externalId: string) => Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        isIdentified: boolean;
+        externalId?: string | null | undefined;
+        identityProvider?: string | undefined;
+        lastIpAddress?: string | undefined;
+    } | null>;
+    /**
+     * Updates an existing subject record by ID.
+     *
+     * Applies any configured hooks during the update process and
+     * processes the output according to schema configuration.
+     *
+     * @param subjectId - The unique identifier of the subject to update
+     * @param data - The fields to update on the subject record
+     * @param context - Optional endpoint context for hooks
+     * @returns The updated subject if successful, null if subject not found or hooks prevented update
+     */
+    updateSubject: (subjectId: string, data: Partial<Subject> & Record<string, unknown>, context?: GenericEndpointContext) => Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        isIdentified: boolean;
+        externalId?: string | null | undefined;
+        identityProvider?: string | undefined;
+        lastIpAddress?: string | undefined;
+    } | null>;
+    /**
+     * Soft deletes a subject and all associated consents from the database.
+     *
+     * This is a cascading operation that marks the subject as deleted by setting
+     * its status to 'deleted' and removes all associated consent records.
+     * The subject record itself remains in the database but is inactive.
+     *
+     * @param subjectId - The unique identifier of the subject to soft delete
+     * @returns A promise that resolves when the soft deletion is complete
+     */
+    deleteSubject: (subjectId: string) => Promise<void>;
+};
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/db/schema/subject/registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEvE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,EAAE,EAAE,eAAe;IAIlE;;;;;;;;;;;OAWG;6BAEO,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC,GACvD,OAAO,CAAC,OAAO,CAAC,YACP,sBAAsB;;;;;;;;;IAiBjC;;;;;;;;OAQG;iFAMA;QACF,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,sBAAsB,CAAC;KACjC;;;;;;;;;IA8JD;;;;;;;OAOG;iCACgC,MAAM;;;;;;;;;IAezC;;;;;;;;OAQG;0CACyC,MAAM;;;;;;;;;IAelD;;;;;;;;;;OAUG;+BAES,MAAM,QACX,OAAO,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YACtC,sBAAsB;;;;;;;;;IAsBjC;;;;;;;;;OASG;+BAC8B,MAAM;EAgCxC"}

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

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+/**
+ * Zod schema for validating subject entities.
+ *
+ * This defines the structure and validation rules for subject records:
+ * - Requires a valid UUID for the ID field
+ * - Default value of false for isIdentified
+ * - Optional fields for externalId, identityProvider, and lastIpAddress
+ * - Default current date/time for creation and update timestamps
+ *
+ * @example
+ * ```typescript
+ * const subjectData = {
+ *   id: 'sub_x1pftyoufsm7xgo1kv',
+ *   externalId: 'ext-123',
+ *   isIdentified: true
+ * };
+ *
+ * // Validate and parse the subject data
+ * const validSubject = subjectSchema.parse(subjectData);
+ * ```
+ */
+export declare const subjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    isIdentified: z.ZodDefault<z.ZodBoolean>;
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    identityProvider: z.ZodOptional<z.ZodString>;
+    lastIpAddress: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodDefault<z.ZodDate>;
+    updatedAt: z.ZodDefault<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isIdentified: boolean;
+    externalId?: string | null | undefined;
+    identityProvider?: string | undefined;
+    lastIpAddress?: string | undefined;
+}, {
+    id: string;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+    isIdentified?: boolean | undefined;
+    externalId?: string | null | undefined;
+    identityProvider?: string | undefined;
+    lastIpAddress?: string | undefined;
+}>;
+/**
+ * Type definition for Subject
+ *
+ * This type represents the structure of a subject record
+ * as defined by the subjectSchema. It includes all fields
+ * that are part of the subject entity.
+ */
+export type Subject = z.infer<typeof subjectSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

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