svelte-firekit 0.0.25 → 0.1.1

package/dist/types/firebase.js

@@ -0,0 +1,33 @@
+/**
+ * Type guard to check if an object contains all required Firebase environment variables
+ */
+export function isValidFirebaseConfig(config) {
+    return (typeof config.apiKey === 'string' &&
+        typeof config.authDomain === 'string' &&
+        typeof config.projectId === 'string' &&
+        typeof config.storageBucket === 'string' &&
+        typeof config.messagingSenderId === 'string' &&
+        typeof config.appId === 'string' &&
+        typeof config.measurementId === 'string');
+}
+/**
+ * Enum representing the initialization status of Firebase services
+ */
+export var FirebaseServiceStatus;
+(function (FirebaseServiceStatus) {
+    FirebaseServiceStatus["UNINITIALIZED"] = "UNINITIALIZED";
+    FirebaseServiceStatus["INITIALIZING"] = "INITIALIZING";
+    FirebaseServiceStatus["INITIALIZED"] = "INITIALIZED";
+    FirebaseServiceStatus["ERROR"] = "ERROR";
+})(FirebaseServiceStatus || (FirebaseServiceStatus = {}));
+/**
+ * Error class for Firebase service initialization failures
+ */
+export class FirebaseServiceError extends Error {
+    service;
+    constructor(message, service) {
+        super(message);
+        this.service = service;
+        this.name = 'FirebaseServiceError';
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './auth.js';
+export * from './firebase.js';
+export type { CollectionState, CollectionOptions, PaginationConfig, CacheConfig, ErrorHandlingConfig, QueryBuilder, FirestoreOperator, CollectionChangeType, DocumentChange, CollectionEventType, CollectionEvent, CollectionEventCallback, CollectionMetadata, CollectionStats, CollectionErrorCode, CollectionError, CollectionSubscription, CollectionQueryResult, CollectionAggregation, ListenerConfig as CollectionListenerConfig, CollectionPerformanceMetrics } from './collection.js';
+export type { DocumentState, DocumentOptions, MutationOptions as DocumentMutationOptions, MutationResponse as DocumentMutationResponse, BatchOperation as DocumentBatchOperation, BatchResult as DocumentBatchResult, ListenerConfig as DocumentListenerConfig, CacheEntry, CacheSource, DocumentErrorCode, DocumentError, DocumentFieldValue, DocumentUpdateData, DocumentMetadata, DocumentSnapshot, DocumentQueryConstraint, DocumentObserver, DocumentSubscription, DocumentAnalytics, DocumentPerformanceMetrics } from './document.js';
+export type { MutationResponse as MutationMutationResponse, MutationMetadata, MutationOptions as MutationMutationOptions, ValidationResult, RetryConfig, TransactionOptions, BatchOperation as MutationBatchOperation, BatchResult as MutationBatchResult, BatchOperationResult, BatchMetadata, MutationOperationType, TimestampFields, FieldValueOperations, ExistenceCheckResult, BulkMutationConfig, OptimisticUpdateConfig, MutationErrorCode, MutationError, MutationEventType, MutationEvent, MutationEventCallback, MutationAnalytics } from './mutations.js';
+export type { GeolocationConfig, PresenceConfig, Location, DeviceInfo, SessionData, UserPresence, PresenceStats, PresenceEventType, PresenceEvent, PresenceEventCallback, GeolocationProvider, SessionStorage, PresenceService, ConnectionInfo, BrowserCapabilities, PresenceFilter, BulkPresenceUpdate, PresenceQueryOptions, CustomPresenceStatus, PresenceAnalytics, PresenceErrorCode, PresenceError } from './presence.js';

package/dist/types/index.js

@@ -0,0 +1,4 @@
+// Auth Types
+export * from './auth.js';
+// Firebase Types
+export * from './firebase.js';

package/dist/types/mutations.d.ts

@@ -0,0 +1,387 @@
+/**
+ * @fileoverview Document mutation types and interfaces for FirekitDocumentMutations
+ * @module MutationTypes
+ * @version 1.0.0
+ */
+import type { FieldValue, Timestamp } from 'firebase/firestore';
+import { CacheSource } from './document.js';
+/**
+ * Response structure for document mutations
+ */
+export interface MutationResponse<T = any> {
+    /** Operation success status */
+    success: boolean;
+    /** Document data */
+    data?: T;
+    /** Document ID */
+    id?: string;
+    /** Error details if operation failed */
+    error?: MutationError;
+    /** Operation metadata */
+    metadata?: MutationMetadata;
+}
+/**
+ * Metadata for mutation operations
+ */
+export interface MutationMetadata {
+    /** Operation timestamp */
+    timestamp: Date;
+    /** Operation type */
+    operation: MutationOperationType;
+    /** Data source */
+    source: CacheSource;
+    /** User who performed the operation */
+    performedBy?: string;
+    /** Duration of operation in milliseconds */
+    duration?: number;
+    /** Whether operation was cached */
+    fromCache?: boolean;
+}
+/**
+ * Options for document mutations
+ */
+export interface MutationOptions {
+    /** Whether to include automatic timestamps */
+    timestamps?: boolean;
+    /** Whether to merge data in set operations */
+    merge?: boolean;
+    /** Custom document ID for add operations */
+    customId?: string;
+    /** Whether to validate data before mutation */
+    validate?: boolean;
+    /** Custom validation function */
+    validator?: (data: any) => ValidationResult;
+    /** Retry configuration */
+    retry?: RetryConfig;
+    /** Whether to perform optimistic updates */
+    optimistic?: boolean;
+    /** Custom metadata to include */
+    customMetadata?: Record<string, any>;
+    /** Transaction options */
+    transaction?: TransactionOptions;
+}
+/**
+ * Validation result interface
+ */
+export interface ValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Validation error message if failed */
+    message?: string;
+    /** Field-specific errors */
+    fieldErrors?: Record<string, string>;
+}
+/**
+ * Retry configuration for failed operations
+ */
+export interface RetryConfig {
+    /** Whether retry is enabled */
+    enabled: boolean;
+    /** Maximum number of retry attempts */
+    maxAttempts: number;
+    /** Base delay between retries in milliseconds */
+    baseDelay: number;
+    /** Backoff strategy */
+    strategy: 'linear' | 'exponential';
+    /** Maximum delay between retries */
+    maxDelay?: number;
+    /** Custom retry condition function */
+    shouldRetry?: (error: MutationError, attempt: number) => boolean;
+}
+/**
+ * Transaction options
+ */
+export interface TransactionOptions {
+    /** Maximum number of transaction attempts */
+    maxAttempts?: number;
+    /** Whether to use batch writes instead of transactions */
+    useBatch?: boolean;
+    /** Custom transaction timeout */
+    timeout?: number;
+}
+/**
+ * Batch operation interface
+ */
+export interface BatchOperation<T = any> {
+    /** Operation type */
+    type: MutationOperationType;
+    /** Document path */
+    path: string;
+    /** Data for create/update operations */
+    data?: T;
+    /** Options specific to this operation */
+    options?: MutationOptions;
+    /** Custom ID for operation tracking */
+    operationId?: string;
+}
+/**
+ * Batch operation result
+ */
+export interface BatchResult {
+    /** Overall batch success status */
+    success: boolean;
+    /** Number of successful operations */
+    successCount: number;
+    /** Number of failed operations */
+    failureCount: number;
+    /** Individual operation results */
+    results: BatchOperationResult[];
+    /** Batch execution metadata */
+    metadata: BatchMetadata;
+}
+/**
+ * Individual batch operation result
+ */
+export interface BatchOperationResult {
+    /** The original operation */
+    operation: BatchOperation;
+    /** Operation success status */
+    success: boolean;
+    /** Result data if successful */
+    data?: any;
+    /** Document ID if applicable */
+    id?: string;
+    /** Error if failed */
+    error?: MutationError;
+    /** Operation execution time */
+    duration?: number;
+}
+/**
+ * Batch operation metadata
+ */
+export interface BatchMetadata {
+    /** Batch execution start time */
+    startTime: Date;
+    /** Batch execution end time */
+    endTime: Date;
+    /** Total execution duration */
+    duration: number;
+    /** Batch size */
+    operationCount: number;
+    /** User who executed the batch */
+    executedBy?: string;
+    /** Batch execution strategy */
+    strategy: 'parallel' | 'sequential';
+}
+/**
+ * Mutation operation types
+ */
+export declare enum MutationOperationType {
+    CREATE = "create",
+    SET = "set",
+    UPDATE = "update",
+    DELETE = "delete",
+    INCREMENT = "increment",
+    ARRAY_UNION = "arrayUnion",
+    ARRAY_REMOVE = "arrayRemove",
+    TRANSACTION = "transaction",
+    READ = "read"
+}
+/**
+ * Document timestamp fields
+ */
+export interface TimestampFields {
+    /** Document creation timestamp */
+    createdAt?: Timestamp | FieldValue;
+    /** Document last update timestamp */
+    updatedAt?: Timestamp | FieldValue;
+    /** User who created the document */
+    createdBy?: string;
+    /** User who last updated the document */
+    updatedBy?: string;
+}
+/**
+ * Field value operations for special Firestore operations
+ */
+export interface FieldValueOperations {
+    /** Server timestamp */
+    serverTimestamp(): FieldValue;
+    /** Increment numeric value */
+    increment(value: number): FieldValue;
+    /** Add elements to array */
+    arrayUnion(...elements: any[]): FieldValue;
+    /** Remove elements from array */
+    arrayRemove(...elements: any[]): FieldValue;
+    /** Delete field */
+    deleteField(): FieldValue;
+}
+/**
+ * Document existence check result
+ */
+export interface ExistenceCheckResult {
+    /** Whether document exists */
+    exists: boolean;
+    /** Document ID if exists */
+    id?: string;
+    /** Last modified timestamp */
+    lastModified?: Date;
+    /** Document metadata */
+    metadata?: {
+        size: number;
+        updateTime: Date;
+        createTime: Date;
+    };
+}
+/**
+ * Bulk mutation configuration
+ */
+export interface BulkMutationConfig {
+    /** Batch size for bulk operations */
+    batchSize?: number;
+    /** Whether to run operations in parallel */
+    parallel?: boolean;
+    /** Maximum concurrency for parallel operations */
+    maxConcurrency?: number;
+    /** Whether to stop on first error */
+    failFast?: boolean;
+    /** Progress callback */
+    onProgress?: (completed: number, total: number) => void;
+    /** Error callback */
+    onError?: (error: MutationError, operation: BatchOperation) => void;
+}
+/**
+ * Optimistic update configuration
+ */
+export interface OptimisticUpdateConfig {
+    /** Whether optimistic updates are enabled */
+    enabled: boolean;
+    /** Rollback strategy on failure */
+    rollbackStrategy: 'automatic' | 'manual';
+    /** Timeout for confirming optimistic update */
+    confirmationTimeout?: number;
+    /** Custom rollback function */
+    rollbackFn?: (originalData: any) => void;
+}
+/**
+ * Mutation error codes enum
+ */
+export declare enum MutationErrorCode {
+    PERMISSION_DENIED = "mutations/permission-denied",
+    NOT_FOUND = "mutations/not-found",
+    ALREADY_EXISTS = "mutations/already-exists",
+    FAILED_PRECONDITION = "mutations/failed-precondition",
+    ABORTED = "mutations/aborted",
+    OUT_OF_RANGE = "mutations/out-of-range",
+    UNIMPLEMENTED = "mutations/unimplemented",
+    INTERNAL_ERROR = "mutations/internal",
+    UNAVAILABLE = "mutations/unavailable",
+    DEADLINE_EXCEEDED = "mutations/deadline-exceeded",
+    UNAUTHENTICATED = "mutations/unauthenticated",
+    RESOURCE_EXHAUSTED = "mutations/resource-exhausted",
+    CANCELLED = "mutations/cancelled",
+    VALIDATION_FAILED = "mutations/validation-failed",
+    REQUIRED_FIELD_MISSING = "mutations/required-field-missing",
+    INVALID_FIELD_TYPE = "mutations/invalid-field-type",
+    INVALID_FIELD_VALUE = "mutations/invalid-field-value",
+    FIELD_TOO_LARGE = "mutations/field-too-large",
+    DOCUMENT_TOO_LARGE = "mutations/document-too-large",
+    INVALID_PATH = "mutations/invalid-path",
+    INVALID_DOCUMENT_ID = "mutations/invalid-document-id",
+    BATCH_TOO_LARGE = "mutations/batch-too-large",
+    TRANSACTION_FAILED = "mutations/transaction-failed",
+    RETRY_EXHAUSTED = "mutations/retry-exhausted",
+    OPTIMISTIC_LOCK_FAILED = "mutations/optimistic-lock-failed",
+    NETWORK_ERROR = "mutations/network-error",
+    TIMEOUT = "mutations/timeout",
+    OFFLINE = "mutations/offline",
+    SERVICE_UNAVAILABLE = "mutations/service-unavailable",
+    QUOTA_EXCEEDED = "mutations/quota-exceeded",
+    UNKNOWN = "mutations/unknown"
+}
+/**
+ * Custom mutation error class
+ */
+export declare class MutationError extends Error {
+    code: MutationErrorCode;
+    operation?: MutationOperationType | undefined;
+    path?: string | undefined;
+    originalError?: any | undefined;
+    context?: Record<string, any> | undefined;
+    constructor(code: MutationErrorCode, message: string, operation?: MutationOperationType | undefined, path?: string | undefined, originalError?: any | undefined, context?: Record<string, any> | undefined);
+    /**
+     * Get user-friendly error message
+     */
+    getFriendlyMessage(): string;
+    /**
+     * Check if error is retryable
+     */
+    isRetryable(): boolean;
+    /**
+     * Check if error requires user authentication
+     */
+    requiresAuth(): boolean;
+    /**
+     * Check if error is a validation error
+     */
+    isValidationError(): boolean;
+    /**
+     * Check if error is permanent (not retryable)
+     */
+    isPermanent(): boolean;
+    /**
+     * Get suggested action for the error
+     */
+    getSuggestedAction(): string;
+    /**
+     * Convert to JSON for logging/debugging
+     */
+    toJSON(): Record<string, any>;
+}
+/**
+ * Mutation event types for tracking operations
+ */
+export type MutationEventType = 'mutation_start' | 'mutation_success' | 'mutation_error' | 'mutation_retry' | 'batch_start' | 'batch_progress' | 'batch_complete' | 'validation_failed' | 'optimistic_update' | 'rollback';
+/**
+ * Mutation event interface
+ */
+export interface MutationEvent {
+    /** Event type */
+    type: MutationEventType;
+    /** Event data */
+    data?: any;
+    /** Error if applicable */
+    error?: MutationError;
+    /** Event timestamp */
+    timestamp: Date;
+    /** Operation ID for tracking */
+    operationId?: string;
+    /** User who triggered the event */
+    userId?: string;
+}
+/**
+ * Mutation event callback function type
+ */
+export type MutationEventCallback = (event: MutationEvent) => void;
+/**
+ * Mutation analytics data
+ */
+export interface MutationAnalytics {
+    /** Total number of mutations */
+    totalMutations: number;
+    /** Number of successful mutations */
+    successfulMutations: number;
+    /** Number of failed mutations */
+    failedMutations: number;
+    /** Success rate percentage */
+    successRate: number;
+    /** Average mutation duration */
+    averageDuration: number;
+    /** Most common error codes */
+    commonErrors: Array<{
+        code: MutationErrorCode;
+        count: number;
+        percentage: number;
+    }>;
+    /** Performance metrics by operation type */
+    performanceByOperation: Record<MutationOperationType, {
+        count: number;
+        averageDuration: number;
+        successRate: number;
+    }>;
+    /** Retry statistics */
+    retryStats: {
+        totalRetries: number;
+        retriesPerMutation: number;
+        retrySuccessRate: number;
+    };
+}

package/dist/types/mutations.js

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview Document mutation types and interfaces for FirekitDocumentMutations
+ * @module MutationTypes
+ * @version 1.0.0
+ */
+import { CacheSource } from './document.js';
+/**
+ * Mutation operation types
+ */
+export var MutationOperationType;
+(function (MutationOperationType) {
+    MutationOperationType["CREATE"] = "create";
+    MutationOperationType["SET"] = "set";
+    MutationOperationType["UPDATE"] = "update";
+    MutationOperationType["DELETE"] = "delete";
+    MutationOperationType["INCREMENT"] = "increment";
+    MutationOperationType["ARRAY_UNION"] = "arrayUnion";
+    MutationOperationType["ARRAY_REMOVE"] = "arrayRemove";
+    MutationOperationType["TRANSACTION"] = "transaction";
+    MutationOperationType["READ"] = "read";
+})(MutationOperationType || (MutationOperationType = {}));
+/**
+ * Mutation error codes enum
+ */
+export var MutationErrorCode;
+(function (MutationErrorCode) {
+    // Firebase errors
+    MutationErrorCode["PERMISSION_DENIED"] = "mutations/permission-denied";
+    MutationErrorCode["NOT_FOUND"] = "mutations/not-found";
+    MutationErrorCode["ALREADY_EXISTS"] = "mutations/already-exists";
+    MutationErrorCode["FAILED_PRECONDITION"] = "mutations/failed-precondition";
+    MutationErrorCode["ABORTED"] = "mutations/aborted";
+    MutationErrorCode["OUT_OF_RANGE"] = "mutations/out-of-range";
+    MutationErrorCode["UNIMPLEMENTED"] = "mutations/unimplemented";
+    MutationErrorCode["INTERNAL_ERROR"] = "mutations/internal";
+    MutationErrorCode["UNAVAILABLE"] = "mutations/unavailable";
+    MutationErrorCode["DEADLINE_EXCEEDED"] = "mutations/deadline-exceeded";
+    MutationErrorCode["UNAUTHENTICATED"] = "mutations/unauthenticated";
+    MutationErrorCode["RESOURCE_EXHAUSTED"] = "mutations/resource-exhausted";
+    MutationErrorCode["CANCELLED"] = "mutations/cancelled";
+    // Validation errors
+    MutationErrorCode["VALIDATION_FAILED"] = "mutations/validation-failed";
+    MutationErrorCode["REQUIRED_FIELD_MISSING"] = "mutations/required-field-missing";
+    MutationErrorCode["INVALID_FIELD_TYPE"] = "mutations/invalid-field-type";
+    MutationErrorCode["INVALID_FIELD_VALUE"] = "mutations/invalid-field-value";
+    MutationErrorCode["FIELD_TOO_LARGE"] = "mutations/field-too-large";
+    MutationErrorCode["DOCUMENT_TOO_LARGE"] = "mutations/document-too-large";
+    // Operation errors
+    MutationErrorCode["INVALID_PATH"] = "mutations/invalid-path";
+    MutationErrorCode["INVALID_DOCUMENT_ID"] = "mutations/invalid-document-id";
+    MutationErrorCode["BATCH_TOO_LARGE"] = "mutations/batch-too-large";
+    MutationErrorCode["TRANSACTION_FAILED"] = "mutations/transaction-failed";
+    MutationErrorCode["RETRY_EXHAUSTED"] = "mutations/retry-exhausted";
+    MutationErrorCode["OPTIMISTIC_LOCK_FAILED"] = "mutations/optimistic-lock-failed";
+    // Network errors
+    MutationErrorCode["NETWORK_ERROR"] = "mutations/network-error";
+    MutationErrorCode["TIMEOUT"] = "mutations/timeout";
+    MutationErrorCode["OFFLINE"] = "mutations/offline";
+    // Service errors
+    MutationErrorCode["SERVICE_UNAVAILABLE"] = "mutations/service-unavailable";
+    MutationErrorCode["QUOTA_EXCEEDED"] = "mutations/quota-exceeded";
+    // Unknown
+    MutationErrorCode["UNKNOWN"] = "mutations/unknown";
+})(MutationErrorCode || (MutationErrorCode = {}));
+/**
+ * Custom mutation error class
+ */
+export class MutationError extends Error {
+    code;
+    operation;
+    path;
+    originalError;
+    context;
+    constructor(code, message, operation, path, originalError, context) {
+        super(message);
+        this.code = code;
+        this.operation = operation;
+        this.path = path;
+        this.originalError = originalError;
+        this.context = context;
+        this.name = 'MutationError';
+    }
+    /**
+     * Get user-friendly error message
+     */
+    getFriendlyMessage() {
+        switch (this.code) {
+            case MutationErrorCode.PERMISSION_DENIED:
+                return 'You do not have permission to perform this operation.';
+            case MutationErrorCode.NOT_FOUND:
+                return 'The document you are trying to update was not found.';
+            case MutationErrorCode.ALREADY_EXISTS:
+                return 'A document with this ID already exists.';
+            case MutationErrorCode.VALIDATION_FAILED:
+                return 'The provided data is invalid.';
+            case MutationErrorCode.REQUIRED_FIELD_MISSING:
+                return 'Required fields are missing.';
+            case MutationErrorCode.INVALID_FIELD_TYPE:
+                return 'One or more fields have incorrect data types.';
+            case MutationErrorCode.DOCUMENT_TOO_LARGE:
+                return 'The document is too large to save.';
+            case MutationErrorCode.NETWORK_ERROR:
+                return 'Network connection error. Please try again.';
+            case MutationErrorCode.TIMEOUT:
+                return 'Operation timed out. Please try again.';
+            case MutationErrorCode.UNAVAILABLE:
+                return 'Service is temporarily unavailable. Please try again later.';
+            case MutationErrorCode.QUOTA_EXCEEDED:
+                return 'Usage quota exceeded. Please try again later.';
+            case MutationErrorCode.UNAUTHENTICATED:
+                return 'Please sign in to perform this operation.';
+            case MutationErrorCode.OFFLINE:
+                return 'You are offline. Changes will be saved when connection is restored.';
+            default:
+                return this.message || 'An unexpected error occurred.';
+        }
+    }
+    /**
+     * Check if error is retryable
+     */
+    isRetryable() {
+        const retryableCodes = [
+            MutationErrorCode.NETWORK_ERROR,
+            MutationErrorCode.TIMEOUT,
+            MutationErrorCode.UNAVAILABLE,
+            MutationErrorCode.INTERNAL_ERROR,
+            MutationErrorCode.ABORTED,
+            MutationErrorCode.DEADLINE_EXCEEDED,
+            MutationErrorCode.CANCELLED
+        ];
+        return retryableCodes.includes(this.code);
+    }
+    /**
+     * Check if error requires user authentication
+     */
+    requiresAuth() {
+        const authCodes = [MutationErrorCode.UNAUTHENTICATED, MutationErrorCode.PERMISSION_DENIED];
+        return authCodes.includes(this.code);
+    }
+    /**
+     * Check if error is a validation error
+     */
+    isValidationError() {
+        const validationCodes = [
+            MutationErrorCode.VALIDATION_FAILED,
+            MutationErrorCode.REQUIRED_FIELD_MISSING,
+            MutationErrorCode.INVALID_FIELD_TYPE,
+            MutationErrorCode.INVALID_FIELD_VALUE,
+            MutationErrorCode.FIELD_TOO_LARGE,
+            MutationErrorCode.DOCUMENT_TOO_LARGE
+        ];
+        return validationCodes.includes(this.code);
+    }
+    /**
+     * Check if error is permanent (not retryable)
+     */
+    isPermanent() {
+        const permanentCodes = [
+            MutationErrorCode.PERMISSION_DENIED,
+            MutationErrorCode.INVALID_PATH,
+            MutationErrorCode.INVALID_DOCUMENT_ID,
+            MutationErrorCode.UNIMPLEMENTED,
+            MutationErrorCode.OUT_OF_RANGE
+        ];
+        return permanentCodes.includes(this.code);
+    }
+    /**
+     * Get suggested action for the error
+     */
+    getSuggestedAction() {
+        if (this.requiresAuth()) {
+            return 'Please sign in and try again.';
+        }
+        if (this.isValidationError()) {
+            return 'Please check your data and try again.';
+        }
+        if (this.isRetryable()) {
+            return 'This appears to be a temporary issue. Please try again.';
+        }
+        if (this.isPermanent()) {
+            return 'Please check your request and contact support if the issue persists.';
+        }
+        return 'Please try again or contact support if the issue persists.';
+    }
+    /**
+     * Convert to JSON for logging/debugging
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            friendlyMessage: this.getFriendlyMessage(),
+            suggestedAction: this.getSuggestedAction(),
+            operation: this.operation,
+            path: this.path,
+            isRetryable: this.isRetryable(),
+            requiresAuth: this.requiresAuth(),
+            isValidationError: this.isValidationError(),
+            isPermanent: this.isPermanent(),
+            context: this.context,
+            timestamp: new Date().toISOString()
+        };
+    }
+}