@aphexcms/cms-core 0.1.16 → 0.2.1

package/dist/lib/field-validation/date-utils.js

@@ -0,0 +1,147 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import utc from 'dayjs/plugin/utc';
+dayjs.extend(customParseFormat);
+dayjs.extend(utc);
+/**
+ * Convert a date value to user format for validation
+ * Handles both ISO format and user format inputs
+ */
+export function convertDateToUserFormat(value, userFormat) {
+    // Try parsing as ISO format first (what DateField stores)
+    // Use strict mode to reject invalid dates
+    const parsedISO = dayjs(value, 'YYYY-MM-DD', true);
+    if (parsedISO.isValid()) {
+        return parsedISO.format(userFormat);
+    }
+    // Try parsing as user format (what API might send)
+    // Use strict mode to reject invalid dates like Feb 31st
+    const parsedUser = dayjs(value, userFormat, true);
+    if (parsedUser.isValid()) {
+        return value; // Already in user format
+    }
+    // Invalid date - return as-is for validation to catch
+    return value;
+}
+/**
+ * Convert a date value to ISO format for storage
+ * Returns ISO if already valid, or original value if invalid
+ */
+export function convertDateToISO(value, userFormat) {
+    // Try parsing as user format first (for API consumers)
+    // Use strict mode to reject invalid dates like Feb 31st
+    const parsedUser = dayjs(value, userFormat, true);
+    if (parsedUser.isValid()) {
+        return parsedUser.format('YYYY-MM-DD');
+    }
+    // Try parsing as ISO (for DateField component)
+    // Use strict mode
+    const parsedISO = dayjs(value, 'YYYY-MM-DD', true);
+    if (parsedISO.isValid()) {
+        return value; // Already ISO
+    }
+    // Invalid date - return as-is
+    return value;
+}
+/**
+ * Convert a datetime value to user format for validation
+ * Handles both ISO datetime and user format inputs
+ */
+export function convertDateTimeToUserFormat(value, dateFormat, timeFormat = 'HH:mm') {
+    const userFormat = `${dateFormat} ${timeFormat}`;
+    // Try parsing as ISO datetime first (what DateTimeField stores)
+    // Use strict mode to reject invalid dates
+    const parsedISO = dayjs(value, 'YYYY-MM-DDTHH:mm:ss[Z]', true);
+    if (parsedISO.isValid()) {
+        return parsedISO.format(userFormat);
+    }
+    // Try parsing as user format (what API might send)
+    // Use strict mode to reject invalid dates like Feb 31st
+    const parsedUser = dayjs(value, userFormat, true);
+    if (parsedUser.isValid()) {
+        return value; // Already in user format
+    }
+    // Invalid datetime - return as-is for validation to catch
+    return value;
+}
+/**
+ * Convert a datetime value to ISO UTC format for storage
+ * Returns ISO UTC if already valid, or original value if invalid
+ */
+export function convertDateTimeToISO(value, dateFormat, timeFormat = 'HH:mm') {
+    const userFormat = `${dateFormat} ${timeFormat}`;
+    console.log('[convertDateTimeToISO]', { value, userFormat });
+    // Try parsing as user format first (for API consumers)
+    // Use strict mode to reject invalid dates like Feb 31st
+    const parsedUser = dayjs(value, userFormat, true);
+    if (parsedUser.isValid()) {
+        const result = parsedUser.utc().format('YYYY-MM-DDTHH:mm:ss[Z]');
+        console.log('[convertDateTimeToISO] User format parse successful, converting to UTC:', result);
+        return result;
+    }
+    // Try parsing as ISO datetime (for DateTimeField component)
+    // Use strict mode with ISO format
+    const parsedISO = dayjs(value, 'YYYY-MM-DDTHH:mm:ss[Z]', true);
+    if (parsedISO.isValid()) {
+        const result = parsedISO.utc().format('YYYY-MM-DDTHH:mm:ss[Z]');
+        console.log('[convertDateTimeToISO] ISO parse successful:', result);
+        return result;
+    }
+    // Invalid datetime - return as-is
+    console.log('[convertDateTimeToISO] Invalid - returning as-is');
+    return value;
+}
+/**
+ * Normalize date fields in data object
+ * Converts dates to ISO for storage and creates a parallel object with user-formatted dates for validation
+ */
+export function normalizeDateFields(data, schema) {
+    const normalizedData = { ...data };
+    const dataForValidation = { ...data };
+    console.log('[normalizeDateFields] Starting normalization...');
+    console.log('[normalizeDateFields] Input data:', data);
+    for (const field of schema.fields) {
+        if (field.type === 'date' && normalizedData[field.name]) {
+            const dateField = field;
+            const userFormat = dateField.options?.dateFormat || 'YYYY-MM-DD';
+            const dateValue = normalizedData[field.name];
+            console.log(`[normalizeDateFields] Processing DATE field "${field.name}"`, {
+                originalValue: dateValue,
+                userFormat
+            });
+            if (typeof dateValue === 'string') {
+                normalizedData[field.name] = convertDateToISO(dateValue, userFormat);
+                dataForValidation[field.name] = convertDateToUserFormat(dateValue, userFormat);
+                console.log(`[normalizeDateFields] Converted DATE field "${field.name}"`, {
+                    normalizedValue: normalizedData[field.name],
+                    validationValue: dataForValidation[field.name]
+                });
+            }
+        }
+        else if (field.type === 'datetime' && normalizedData[field.name]) {
+            const dateTimeField = field;
+            const dateFormat = dateTimeField.options?.dateFormat || 'YYYY-MM-DD';
+            const timeFormat = dateTimeField.options?.timeFormat || 'HH:mm';
+            const dateTimeValue = normalizedData[field.name];
+            console.log(`[normalizeDateFields] Processing DATETIME field "${field.name}"`, {
+                originalValue: dateTimeValue,
+                dateFormat,
+                timeFormat,
+                combinedFormat: `${dateFormat} ${timeFormat}`
+            });
+            if (typeof dateTimeValue === 'string') {
+                normalizedData[field.name] = convertDateTimeToISO(dateTimeValue, dateFormat, timeFormat);
+                dataForValidation[field.name] = convertDateTimeToUserFormat(dateTimeValue, dateFormat, timeFormat);
+                console.log(`[normalizeDateFields] Converted DATETIME field "${field.name}"`, {
+                    normalizedValue: normalizedData[field.name],
+                    validationValue: dataForValidation[field.name]
+                });
+            }
+        }
+    }
+    console.log('[normalizeDateFields] Final result:', {
+        normalizedData,
+        dataForValidation
+    });
+    return { normalizedData, dataForValidation };
+}

package/dist/lib/field-validation/rule.js

@@ -1,3 +1,8 @@
+// Sanity-style validation Rule implementation
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+// Enable strict parsing
+dayjs.extend(customParseFormat);
 export class Rule {
     _required = false;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -39,6 +44,11 @@ export class Rule {
         newRule._rules.push({ type: 'length', constraint: len });
         return newRule;
     }
+    unique() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'unique' });
+        return newRule;
+    }
     email() {
         const newRule = this.clone();
         newRule._rules.push({ type: 'email' });
@@ -79,6 +89,17 @@ export class Rule {
         newRule._rules.push({ type: 'lessThan', constraint: num });
         return newRule;
     }
+    date(format) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'date', constraint: format || 'YYYY-MM-DD' });
+        return newRule;
+    }
+    datetime(dateFormat, timeFormat) {
+        const newRule = this.clone();
+        const fullFormat = `${dateFormat || 'YYYY-MM-DD'} ${timeFormat || 'HH:mm'}`;
+        newRule._rules.push({ type: 'datetime', constraint: fullFormat });
+        return newRule;
+    }
     custom(fn) {
         const newRule = this.clone();
         newRule._rules.push({ type: 'custom', constraint: fn });
@@ -155,6 +176,9 @@ export class Rule {
                 if (typeof value === 'number' && value < rule.constraint) {
                     return `Must be at least ${rule.constraint}`;
                 }
+                if (Array.isArray(value) && value.length < rule.constraint) {
+                    return `Must have at least ${rule.constraint} item${rule.constraint === 1 ? '' : 's'}`;
+                }
                 break;
             case 'max':
                 if (typeof value === 'string' && value.length > rule.constraint) {
@@ -163,6 +187,31 @@ export class Rule {
                 if (typeof value === 'number' && value > rule.constraint) {
                     return `Must be at most ${rule.constraint}`;
                 }
+                if (Array.isArray(value) && value.length > rule.constraint) {
+                    return `Must have at most ${rule.constraint} item${rule.constraint === 1 ? '' : 's'}`;
+                }
+                break;
+            case 'length':
+                if (Array.isArray(value) && value.length !== rule.constraint) {
+                    return `Must have exactly ${rule.constraint} item${rule.constraint === 1 ? '' : 's'}`;
+                }
+                if (typeof value === 'string' && value.length !== rule.constraint) {
+                    return `Must be exactly ${rule.constraint} characters`;
+                }
+                break;
+            case 'unique':
+                if (Array.isArray(value)) {
+                    const seen = new Set();
+                    for (const item of value) {
+                        // Deep comparison excluding _key property
+                        const normalized = this.normalizeForComparison(item);
+                        const serialized = JSON.stringify(normalized);
+                        if (seen.has(serialized)) {
+                            return 'All items must be unique';
+                        }
+                        seen.add(serialized);
+                    }
+                }
                 break;
             case 'email':
                 if (typeof value === 'string' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
@@ -171,11 +220,57 @@ export class Rule {
                 break;
             case 'uri':
                 if (typeof value === 'string') {
-                    try {
-                        new URL(value);
+                    const opts = rule.constraint || {};
+                    const schemes = opts.scheme || [/^https?$/];
+                    const allowRelative = opts.allowRelative || false;
+                    const relativeOnly = opts.relativeOnly || false;
+                    // Check if URL is relative (doesn't have a scheme)
+                    const hasScheme = /^[a-z][a-z0-9+.-]*:/i.test(value);
+                    const isProtocolRelative = value.startsWith('//');
+                    if (relativeOnly) {
+                        // Only allow relative URLs
+                        if (hasScheme || isProtocolRelative) {
+                            return 'Must be a relative URL';
+                        }
+                        // Validate it's a reasonable path
+                        if (!value.startsWith('/') &&
+                            !value.startsWith('.') &&
+                            !value.startsWith('#') &&
+                            !value.startsWith('?')) {
+                            return 'Must be a relative URL starting with /, ., #, or ?';
+                        }
                     }
-                    catch {
-                        return 'Must be a valid URL';
+                    else if (!hasScheme && !isProtocolRelative) {
+                        // It's a relative URL
+                        if (!allowRelative) {
+                            return 'Must be an absolute URL';
+                        }
+                        // Validate it's a reasonable relative path
+                        if (!value.startsWith('/') &&
+                            !value.startsWith('.') &&
+                            !value.startsWith('#') &&
+                            !value.startsWith('?')) {
+                            return 'Must be a valid relative URL';
+                        }
+                    }
+                    else {
+                        // It's an absolute URL, validate with URL constructor
+                        try {
+                            const url = new URL(value);
+                            // Extract scheme without the trailing colon
+                            const urlScheme = url.protocol.slice(0, -1);
+                            // Check if scheme is allowed
+                            const schemeMatches = schemes.some((s) => s instanceof RegExp ? s.test(urlScheme) : s === urlScheme);
+                            if (!schemeMatches) {
+                                const schemeList = schemes
+                                    .map((s) => (s instanceof RegExp ? s.toString() : s))
+                                    .join(', ');
+                                return `URL scheme must be one of: ${schemeList}`;
+                            }
+                        }
+                        catch {
+                            return 'Must be a valid URL';
+                        }
                     }
                 }
                 break;
@@ -199,6 +294,58 @@ export class Rule {
                     return 'Must be an integer';
                 }
                 break;
+            case 'date': {
+                if (typeof value === 'string') {
+                    const format = rule.constraint || 'YYYY-MM-DD';
+                    console.log('[Rule.validate] DATE validation', { value, format });
+                    // Parse with strict mode
+                    const parsed = dayjs(value, format, true);
+                    console.log('[Rule.validate] DATE parsed', {
+                        isValid: parsed.isValid(),
+                        parsed: parsed.format()
+                    });
+                    if (!parsed.isValid()) {
+                        console.log('[Rule.validate] DATE validation FAILED - invalid format');
+                        return `Invalid date format. Expected: ${format}`;
+                    }
+                    // Verify the parsed date matches the input (catches invalid dates like 2025-02-31)
+                    if (parsed.format(format) !== value) {
+                        console.log('[Rule.validate] DATE validation FAILED - format mismatch', {
+                            expected: value,
+                            got: parsed.format(format)
+                        });
+                        return `Invalid date. Expected format: ${format}`;
+                    }
+                    console.log('[Rule.validate] DATE validation PASSED');
+                }
+                break;
+            }
+            case 'datetime': {
+                if (typeof value === 'string') {
+                    const format = rule.constraint || 'YYYY-MM-DD HH:mm';
+                    console.log('[Rule.validate] DATETIME validation', { value, format });
+                    // Parse with strict mode
+                    const parsed = dayjs(value, format, true);
+                    console.log('[Rule.validate] DATETIME parsed', {
+                        isValid: parsed.isValid(),
+                        parsed: parsed.format()
+                    });
+                    if (!parsed.isValid()) {
+                        console.log('[Rule.validate] DATETIME validation FAILED - invalid format');
+                        return `Invalid datetime format. Expected: ${format}`;
+                    }
+                    // Verify the parsed datetime matches the input (catches invalid dates like 2025-02-31 23:59)
+                    if (parsed.format(format) !== value) {
+                        console.log('[Rule.validate] DATETIME validation FAILED - format mismatch', {
+                            expected: value,
+                            got: parsed.format(format)
+                        });
+                        return `Invalid datetime. Expected format: ${format}`;
+                    }
+                    console.log('[Rule.validate] DATETIME validation PASSED');
+                }
+                break;
+            }
             case 'custom': {
                 const customResult = await rule.constraint(value, context);
                 if (customResult === false) {
@@ -218,4 +365,23 @@ export class Rule {
     isRequired() {
         return this._required;
     }
+    // Helper method to normalize objects for comparison (exclude _key)
+    normalizeForComparison(value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.normalizeForComparison(item));
+        }
+        if (typeof value === 'object') {
+            const normalized = {};
+            for (const [key, val] of Object.entries(value)) {
+                if (key !== '_key') {
+                    normalized[key] = this.normalizeForComparison(val);
+                }
+            }
+            return normalized;
+        }
+        return value;
+    }
 }

package/dist/lib/field-validation/utils.js

@@ -1,4 +1,5 @@
 import { Rule } from './rule.js';
+import { normalizeDateFields } from './date-utils.js';
 /**
  * Check if a field is required based on its validation rules
  */
@@ -20,39 +21,106 @@ export function isFieldRequired(field) {
  * Validate a field value against its validation rules
  */
 export async function validateField(field, value, context = {}) {
-    if (!field.validation) {
-        return { isValid: true, errors: [] };
+    console.log(`[validateField] Validating field "${field.name}"`, {
+        type: field.type,
+        value,
+        hasValidation: !!field.validation
+    });
+    const allErrors = [];
+    // Add automatic validation for date/datetime/url fields based on type
+    if (field.type === 'date') {
+        const dateField = field;
+        const dateFormat = dateField.options?.dateFormat || 'YYYY-MM-DD';
+        console.log(`[validateField] Adding automatic DATE validation for "${field.name}"`, {
+            dateFormat
+        });
+        const autoRule = new Rule().date(dateFormat);
+        const markers = await autoRule.validate(value, {
+            path: [field.name],
+            ...context
+        });
+        allErrors.push(...markers.map((marker) => ({
+            level: marker.level,
+            message: marker.message
+        })));
     }
-    try {
-        const validationFunctions = Array.isArray(field.validation)
-            ? field.validation
-            : [field.validation];
-        const allErrors = [];
-        for (const validationFn of validationFunctions) {
-            const rule = validationFn(new Rule());
-            if (!(rule instanceof Rule)) {
-                console.error(`Validation function for field "${field.name}" did not return a Rule object. Make sure you are chaining validation methods and returning the result.`);
-                continue;
+    else if (field.type === 'datetime') {
+        const dateTimeField = field;
+        const dateFormat = dateTimeField.options?.dateFormat || 'YYYY-MM-DD';
+        const timeFormat = dateTimeField.options?.timeFormat || 'HH:mm';
+        console.log(`[validateField] Adding automatic DATETIME validation for "${field.name}"`, {
+            dateFormat,
+            timeFormat
+        });
+        const autoRule = new Rule().datetime(dateFormat, timeFormat);
+        const markers = await autoRule.validate(value, {
+            path: [field.name],
+            ...context
+        });
+        allErrors.push(...markers.map((marker) => ({
+            level: marker.level,
+            message: marker.message
+        })));
+    }
+    else if (field.type === 'url') {
+        // Only add automatic URL validation if there's no custom validation
+        // This allows custom validation to specify different options (scheme, allowRelative, relativeOnly)
+        if (!field.validation) {
+            console.log(`[validateField] Adding automatic URL validation for "${field.name}"`);
+            // Automatic URL validation - only validate if there's a value
+            if (value && value !== '') {
+                const autoRule = new Rule().uri();
+                const markers = await autoRule.validate(value, {
+                    path: [field.name],
+                    ...context
+                });
+                allErrors.push(...markers.map((marker) => ({
+                    level: marker.level,
+                    message: marker.message
+                })));
             }
-            const markers = await rule.validate(value, {
-                path: [field.name],
-                ...context
-            });
-            allErrors.push(...markers.map((marker) => ({
-                level: marker.level,
-                message: marker.message
-            })));
         }
-        const isValid = allErrors.filter((e) => e.level === 'error').length === 0;
-        return { isValid, errors: allErrors };
+        else {
+            console.log(`[validateField] Skipping automatic URL validation for "${field.name}" (has custom validation)`);
+        }
+    }
+    // Run user-defined validation rules if present
+    if (!field.validation) {
+        console.log(`[validateField] No custom validation rules for "${field.name}"`);
     }
-    catch (error) {
-        console.error('Validation error:', error);
-        return {
-            isValid: false,
-            errors: [{ level: 'error', message: 'Validation failed' }]
-        };
+    else {
+        try {
+            const validationFunctions = Array.isArray(field.validation)
+                ? field.validation
+                : [field.validation];
+            console.log(`[validateField] Field "${field.name}" has ${validationFunctions.length} custom validation function(s)`);
+            for (const validationFn of validationFunctions) {
+                const rule = validationFn(new Rule());
+                if (!(rule instanceof Rule)) {
+                    console.error(`Validation function for field "${field.name}" did not return a Rule object. Make sure you are chaining validation methods and returning the result.`);
+                    continue;
+                }
+                const markers = await rule.validate(value, {
+                    path: [field.name],
+                    ...context
+                });
+                allErrors.push(...markers.map((marker) => ({
+                    level: marker.level,
+                    message: marker.message
+                })));
+            }
+        }
+        catch (error) {
+            console.error(`[validateField] Validation error for "${field.name}":`, error);
+            allErrors.push({ level: 'error', message: 'Validation failed' });
+        }
     }
+    const isValid = allErrors.filter((e) => e.level === 'error').length === 0;
+    console.log(`[validateField] Field "${field.name}" validation complete`, {
+        isValid,
+        errors: allErrors
+    });
+    return { isValid, errors: allErrors };
 }
 /**
  * Get validation CSS classes for input styling
@@ -66,24 +134,43 @@ export function getValidationClasses(hasErrors) {
 }
 /**
  * Validate an entire document's data against a schema
- * This function validates all fields in a schema against the provided data
- * and returns any validation errors found.
+ * This function:
+ * 1. Normalizes date fields (converts user format to ISO for storage)
+ * 2. Converts ISO dates to user format for validation
+ * 3. Validates all fields and returns errors
+ * 4. Returns normalized data (with ISO dates) for storage
  *
  * @param schema - The schema type containing field definitions
  * @param data - The document data to validate
  * @param context - Optional context to pass to field validators
- * @returns Validation result with isValid flag and array of field errors
+ * @returns Validation result with isValid flag, errors, and normalized data
  */
 export async function validateDocumentData(schema, data, context = {}) {
+    console.log('[validateDocumentData] Starting validation', {
+        schemaName: schema.name,
+        data
+    });
     const validationErrors = [];
-    // Validate each field in the schema
+    // Normalize date fields: convert to ISO for storage, user format for validation
+    const { normalizedData, dataForValidation } = normalizeDateFields(data, schema);
+    console.log('[validateDocumentData] After normalization', {
+        normalizedData,
+        dataForValidation
+    });
+    // Validate each field using the user-formatted data
     for (const field of schema.fields) {
-        const value = data[field.name];
-        const result = await validateField(field, value, { ...context, ...data });
+        const value = dataForValidation[field.name];
+        console.log(`[validateDocumentData] Validating field "${field.name}"`, {
+            type: field.type,
+            value
+        });
+        const result = await validateField(field, value, { ...context, ...dataForValidation });
+        console.log(`[validateDocumentData] Field "${field.name}" validation result`, {
+            isValid: result.isValid,
+            errors: result.errors
+        });
         if (!result.isValid) {
-            const errorMessages = result.errors
-                .filter((e) => e.level === 'error')
-                .map((e) => e.message);
+            const errorMessages = result.errors.filter((e) => e.level === 'error').map((e) => e.message);
             if (errorMessages.length > 0) {
                 validationErrors.push({
                     field: field.name,
@@ -92,8 +179,13 @@ export async function validateDocumentData(schema, data, context = {}) {
             }
         }
     }
-    return {
+    console.log('[validateDocumentData] Final result', {
         isValid: validationErrors.length === 0,
         errors: validationErrors
+    });
+    return {
+        isValid: validationErrors.length === 0,
+        errors: validationErrors,
+        normalizedData
     };
 }

package/dist/local-api/collection-api.d.ts

@@ -4,6 +4,14 @@ import type { Document } from '../types/document.js';
 import type { LocalAPIContext } from './types.js';
 import type { SchemaType } from '../types/schemas.js';
 import { PermissionChecker } from './permissions.js';
+import { type DocumentValidationResult } from '../field-validation/utils.js';
+/**
+ * Result from create/update operations that includes validation
+ */
+export interface DocumentResult<T> {
+    document: T;
+    validation: DocumentValidationResult;
+}
 /**
  * Collection API - provides type-safe operations for a single collection
  * Generic type T represents the document type for this collection
@@ -69,7 +77,7 @@ export declare class CollectionAPI<T = Document> {
      *
      * @example
      * ```typescript
-     * const page = await api.collections.pages.create(
+     * const result = await api.collections.pages.create(
      *   { organizationId: 'org_123', user },
      *   {
      *     title: 'New Page',
@@ -77,27 +85,31 @@ export declare class CollectionAPI<T = Document> {
      *     content: []
      *   }
      * );
+     * // result.document - the created document
+     * // result.validation - validation results
      * ```
      */
     create(context: LocalAPIContext, data: Omit<T, 'id' | '_meta'>, options?: {
         publish?: boolean;
-    }): Promise<T>;
+    }): Promise<DocumentResult<T>>;
     /**
      * Update an existing document
      *
      * @example
      * ```typescript
-     * const updated = await api.collections.pages.update(
+     * const result = await api.collections.pages.update(
      *   { organizationId: 'org_123', user },
      *   'doc_123',
      *   { title: 'Updated Title' },
      *   { publish: true }
      * );
+     * // result.document - the updated document
+     * // result.validation - validation results
      * ```
      */
     update(context: LocalAPIContext, id: string, data: Partial<Omit<T, 'id' | '_meta'>>, options?: {
         publish?: boolean;
-    }): Promise<T | null>;
+    }): Promise<DocumentResult<T> | null>;
     /**
      * Delete a document
      *

package/dist/local-api/collection-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection-api.d.ts","sourceRoot":"","sources":["../../src/lib/local-api/collection-api.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AA6BlD;;;GAGG;AACH,qBAAa,aAAa,CAAC,CAAC,GAAG,QAAQ;IAErC,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,WAAW;gBAHX,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,UAAU,EACnB,WAAW,EAAE,iBAAiB;IAMvC;;OAEG;IACH,IAAI,MAAM,IAAI,UAAU,CAEvB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACG,IAAI,CACT,OAAO,EAAE,eAAe,EACxB,OAAO,GAAE,WAAW,CAAC,CAAC,CAAM,GAC1B,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAqBzB;;;;;;;;;;;OAWG;IACG,QAAQ,CACb,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAC/B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAmBpB;;;;;;;;;;OAUG;IACG,KAAK,CACV,OAAO,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;KAAE,GACzC,OAAO,CAAC,MAAM,CAAC;IAWlB;;;;;;;;;;;;;;OAcG;IACG,MAAM,CACX,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7B,OAAO,CAAC,CAAC,CAAC;IAuCb;;;;;;;;;;;;OAYG;IACG,MAAM,CACX,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,EACtC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IA6CpB;;;;;;;;;;OAUG;IACG,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOpE;;;;;;;;;;OAUG;IACG,OAAO,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAgCtE;;;;;;;;;;OAUG;IACG,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CAUxE"}
+{"version":3,"file":"collection-api.d.ts","sourceRoot":"","sources":["../../src/lib/local-api/collection-api.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAwB,KAAK,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAEhG;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAChC,QAAQ,EAAE,CAAC,CAAC;IACZ,UAAU,EAAE,wBAAwB,CAAC;CACrC;AA4BD;;;GAGG;AACH,qBAAa,aAAa,CAAC,CAAC,GAAG,QAAQ;IAErC,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,WAAW;gBAHX,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,UAAU,EACnB,WAAW,EAAE,iBAAiB;IAMvC;;OAEG;IACH,IAAI,MAAM,IAAI,UAAU,CAEvB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACG,IAAI,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,GAAE,WAAW,CAAC,CAAC,CAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAqB1F;;;;;;;;;;;OAWG;IACG,QAAQ,CACb,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAC/B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAmBpB;;;;;;;;;;OAUG;IACG,KAAK,CACV,OAAO,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;KAAE,GACzC,OAAO,CAAC,MAAM,CAAC;IAWlB;;;;;;;;;;;;;;;;OAgBG;IACG,MAAM,CACX,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7B,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IA4C7B;;;;;;;;;;;;;;OAcG;IACG,MAAM,CACX,OAAO,EAAE,eAAe,EACxB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,EACtC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAC7B,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAkEpC;;;;;;;;;;OAUG;IACG,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOpE;;;;;;;;;;OAUG;IACG,OAAO,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAgCtE;;;;;;;;;;OAUG;IACG,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CAUxE"}