@factor_ec/utils 5.0.9 → 6.0.0

package/types/factor_ec-utils.d.ts

@@ -0,0 +1,894 @@
+import * as i0 from '@angular/core';
+import { Signal, InjectionToken } from '@angular/core';
+import { Router, CanActivateFn } from '@angular/router';
+import { ValidatorFn } from '@angular/forms';
+import { HttpRequest, HttpErrorResponse, HttpHandlerFn, HttpInterceptorFn } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+/**
+ * Utility service for array operations.
+ *
+ * @remarks
+ * Provides helper methods for common array manipulation tasks.
+ */
+declare class ArrayUtil {
+    /**
+     * Merges multiple arrays into a single array, combining objects with the same property value.
+     *
+     * @param arrays - Array of arrays to merge
+     * @param prop - Property name to use as the key for merging objects
+     * @returns Merged array with combined objects
+     *
+     * @example
+     * ```typescript
+     * const arr1 = [{ id: 1, name: 'John' }];
+     * const arr2 = [{ id: 1, age: 30 }];
+     * const result = arrayUtil.merge([arr1, arr2], 'id');
+     * // Returns: [{ id: 1, name: 'John', age: 30 }]
+     * ```
+     */
+    merge(arrays: any[], prop: string): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayUtil, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArrayUtil>;
+}
+
+/**
+ * Utility service for color operations and hash-based color generation.
+ *
+ * @remarks
+ * Provides methods to generate consistent colors from strings using hash algorithms,
+ * and convert between different color formats (HSL, RGB, HEX).
+ *
+ * @example
+ * ```typescript
+ * const colorUtil = inject(ColorUtil);
+ * const hexColor = colorUtil.hex('username');
+ * // Returns: '#a1b2c3' (consistent color for the same string)
+ * ```
+ */
+declare class ColorUtil {
+    private readonly L;
+    private readonly S;
+    private readonly hueRanges;
+    constructor();
+    /**
+     * Generates a hash value from a string using BKDR hash algorithm (modified version).
+     *
+     * @param str - The string to hash
+     * @returns A numeric hash value
+     *
+     * @remarks
+     * This is a modified BKDR hash algorithm optimized for short strings.
+     */
+    hash(str: string): number;
+    /**
+     * Converts an RGB array to a hexadecimal color string.
+     *
+     * @param RGBArray - Array with [R, G, B] values (0-255)
+     * @returns Hexadecimal color string starting with # (e.g., '#a1b2c3')
+     */
+    rgb2hex(RGBArray: number[]): string;
+    /**
+     * Converts HSL color values to RGB array.
+     *
+     * @param H - Hue value in range [0, 360)
+     * @param S - Saturation value in range [0, 1]
+     * @param L - Lightness value in range [0, 1]
+     * @returns Array with [R, G, B] values in range [0, 255]
+     *
+     * @see {@link http://zh.wikipedia.org/wiki/HSL和HSV色彩空间} for further information.
+     */
+    hsl2rgb(H: number, S: number, L: number): number[];
+    /**
+     * Generates HSL color values from a string hash.
+     *
+     * @param str - The string to generate color from
+     * @returns Array with [H, S, L] values where H ∈ [0, 360), S ∈ [0, 1], L ∈ [0, 1]
+     */
+    hsl(str: string): number[];
+    /**
+     * Generates RGB color values from a string hash.
+     *
+     * @param str - The string to generate color from
+     * @returns Array with [R, G, B] values in range [0, 255]
+     */
+    rgb(str: string): number[];
+    /**
+     * Generates a hexadecimal color string from a string hash.
+     *
+     * @param str - The string to generate color from
+     * @returns Hexadecimal color string starting with # (e.g., '#a1b2c3')
+     *
+     * @example
+     * ```typescript
+     * const color = colorUtil.hex('username');
+     * // Returns: '#a1b2c3' (same string always returns same color)
+     * ```
+     */
+    hex(str: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorUtil, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColorUtil>;
+}
+
+/**
+ * Parsed CSV data structure.
+ */
+interface CsvParsed {
+    /** Array of header column names */
+    header: string[];
+    /** Two-dimensional array of content rows */
+    content: string[][];
+}
+/**
+ * Configuration options for CSV export.
+ */
+interface CsvOptions {
+    /** Name of the exported file (without extension) */
+    filename: string;
+    /** Character used to separate fields (default: ',') */
+    fieldSeparator: string;
+    /** Character used to quote strings (default: '"') */
+    quoteStrings: string;
+    /** Decimal separator for numbers (default: '.' or 'locale') */
+    decimalSeparator: string;
+    /** Whether to show column headers */
+    showLabels: boolean;
+    /** Whether to show a title row */
+    showTitle: boolean;
+    /** Title text to display if showTitle is true */
+    title: string;
+    /** Whether to export as .txt instead of .csv */
+    useTextFile: boolean;
+    /** Whether to include BOM (Byte Order Mark) for UTF-8 */
+    useBom: boolean;
+    /** Custom header names (if not using keys as headers) */
+    headers: string[];
+    /** Whether to use object keys as header names */
+    useKeysAsHeaders: boolean;
+}
+
+/**
+ * Service for exporting data to CSV format and parsing CSV content.
+ *
+ * @remarks
+ * Provides functionality to generate CSV files from JSON data with customizable options,
+ * and to parse CSV content back into structured data.
+ *
+ * @example
+ * ```typescript
+ * const csvExporter = inject(CsvExporter);
+ * csvExporter.options = { filename: 'export', showLabels: true };
+ * csvExporter.generate([{ name: 'John', age: 30 }]);
+ * ```
+ */
+declare class CsvExporter {
+    private _data;
+    private _options;
+    private _csv;
+    private readonly configDefaults;
+    get options(): CsvOptions;
+    set options(options: Partial<CsvOptions>);
+    constructor();
+    /**
+     * Generates a CSV file from JSON data and optionally downloads it.
+     *
+     * @param jsonData - The data to export (array of objects or JSON string)
+     * @param shouldReturnCsv - If true, returns the CSV string instead of downloading
+     * @returns The CSV string if shouldReturnCsv is true, otherwise void
+     *
+     * @example
+     * ```typescript
+     * // Download CSV
+     * csvExporter.generate([{ name: 'John', age: 30 }]);
+     *
+     * // Get CSV string
+     * const csvString = csvExporter.generate([{ name: 'John' }], true);
+     * ```
+     */
+    generate(jsonData: any, shouldReturnCsv?: boolean): void | any;
+    /**
+     * Creates CSV headers row based on configuration.
+     *
+     * @private
+     */
+    private _getHeaders;
+    /**
+     * Creates CSV body rows from the data.
+     *
+     * @private
+     */
+    private _getBody;
+    /**
+     * Formats data for CSV output according to configuration.
+     *
+     * @param data - The data value to format
+     * @returns The formatted data as a string
+     * @private
+     */
+    private _formatData;
+    /**
+     * Checks if a value is a floating point number.
+     *
+     * @param input - The value to check
+     * @returns True if the value is a float, false otherwise
+     * @private
+     */
+    private _isFloat;
+    /**
+     * Parses JSON data into an array format.
+     *
+     * @param jsonData - The JSON data to parse (object, array, or JSON string)
+     * @returns Parsed array of data
+     * @private
+     */
+    private _parseData;
+    /**
+     * Converts a value to an object, throwing an error for null or undefined.
+     *
+     * @param val - The value to convert
+     * @returns The value as an object
+     * @throws {TypeError} If val is null or undefined
+     */
+    toObject(val: any): any;
+    /**
+     * Assigns properties from source objects to a target object (similar to Object.assign).
+     *
+     * @param target - The target object to assign properties to
+     * @param source - One or more source objects to copy properties from
+     * @returns The target object with assigned properties
+     */
+    objectAssign(target: any, ...source: any[]): any;
+    /**
+     * Parses CSV content into a structured format with headers and content rows.
+     *
+     * @param csvContent - The CSV string to parse
+     * @returns An object containing the header array and content rows array
+     *
+     * @example
+     * ```typescript
+     * const parsed = csvExporter.read('name,age\nJohn,30\nJane,25');
+     * // Returns: { header: ['name', 'age'], content: [['John', '30'], ['Jane', '25']] }
+     * ```
+     */
+    read(csvContent: string): CsvParsed;
+    /**
+     * Parses a single CSV line into an array of values.
+     *
+     * @param csvLine - A single line of CSV content
+     * @returns Array of parsed values from the line
+     *
+     * @remarks
+     * Handles quoted values and different quote styles (single and double quotes).
+     */
+    parseLine(csvLine: string): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CsvExporter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CsvExporter>;
+}
+
+/**
+ * Utility service for date operations.
+ *
+ * @remarks
+ * Provides helper methods for date parsing and manipulation.
+ */
+declare class DateUtil {
+    /**
+     * Parses a date string in ISO format (YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss) and returns a Date object.
+     *
+     * @param date - The date string to parse (ISO format)
+     * @returns A Date object representing the parsed date
+     *
+     * @example
+     * ```typescript
+     * const date = dateUtil.getDate('2025-01-15');
+     * // Returns: Date object for January 15, 2025
+     * ```
+     */
+    getDate(date: string): Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateUtil, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateUtil>;
+}
+
+/**
+ * Service for opening file picker dialogs and reading file contents.
+ *
+ * @remarks
+ * Provides a programmatic way to open file selection dialogs and read file data as base64.
+ */
+declare class FilePicker {
+    /**
+     * Opens a file picker dialog and returns the selected files with their data as base64.
+     *
+     * @param options - Optional configuration for the file picker
+     * @param options.accept - File types to accept (e.g., 'image/*', '.pdf')
+     * @param options.multiple - Whether to allow multiple file selection
+     * @returns Promise that resolves to an array of files with data property, or null if cancelled
+     *
+     * @example
+     * ```typescript
+     * const files = await filePicker.open({ accept: 'image/*', multiple: true });
+     * if (files) {
+     *   files.forEach(file => console.log(file.data)); // base64 data
+     * }
+     * ```
+     */
+    open(options?: {
+        accept?: string;
+        multiple?: boolean;
+    }): Promise<any[] | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilePicker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilePicker>;
+}
+
+/**
+ * Utility service for object operations.
+ *
+ * @remarks
+ * Provides helper methods for object manipulation and transformation.
+ */
+declare class ObjectUtil {
+    /**
+     * Filters out null, undefined, and 'undefined' string properties from an object.
+     *
+     * @param obj - The object to filter
+     * @returns A new object with null/undefined properties removed
+     *
+     * @example
+     * ```typescript
+     * const filtered = objectUtil.filterNullProperties({ a: 1, b: null, c: undefined });
+     * // Returns: { a: 1 }
+     * ```
+     */
+    filterNullProperties(obj: any): any;
+    /**
+     * Performs a deep merge of two objects, combining nested properties.
+     *
+     * @param target - The target object to merge into
+     * @param source - The source object to merge from
+     * @returns A new object with deeply merged properties
+     *
+     * @remarks
+     * Uses structuredClone to avoid mutating the original objects.
+     *
+     * @example
+     * ```typescript
+     * const merged = objectUtil.deepMerge({ a: { b: 1 } }, { a: { c: 2 } });
+     * // Returns: { a: { b: 1, c: 2 } }
+     * ```
+     */
+    deepMerge(target: any, source: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectUtil, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectUtil>;
+}
+
+/**
+ * Constants for storage type options.
+ */
+declare const STORAGE_TYPE: {
+    /** Browser localStorage */
+    readonly LOCAL: "local";
+    /** Browser sessionStorage */
+    readonly SESSION: "session";
+    /** In-memory storage (not persisted) */
+    readonly MEMORY: "memory";
+};
+/**
+ * Type representing valid storage types.
+ */
+type StorageType = (typeof STORAGE_TYPE)[keyof typeof STORAGE_TYPE];
+
+/**
+ * Service for managing browser storage (localStorage, sessionStorage, and memory storage).
+ *
+ * @remarks
+ * Provides a unified interface for storing and retrieving data from different storage types.
+ * Automatically handles JSON serialization/deserialization and platform detection.
+ *
+ * @example
+ * ```typescript
+ * const storage = inject(Storage);
+ * storage.set('key', { data: 'value' }, 'local');
+ * const value = storage.get('key', 'local');
+ * ```
+ */
+declare class Storage {
+    private memoryStorage;
+    private readonly platformId;
+    private getValue;
+    /**
+     * Deletes a value from the specified storage.
+     *
+     * @param key - The key of the value to delete
+     * @param storage - The storage type ('local', 'session', or 'memory'). Defaults to 'session'
+     */
+    delete(key: string, storage?: StorageType): void;
+    /**
+     * Retrieves a value from the specified storage.
+     *
+     * @param key - The key of the value to retrieve
+     * @param storage - The storage type ('local', 'session', or 'memory'). Defaults to 'session'
+     * @returns The parsed value (if JSON) or the raw value, or undefined if not found
+     *
+     * @remarks
+     * Automatically attempts to parse JSON values. If parsing fails, returns the raw string.
+     */
+    get(key: string, storage?: StorageType): any;
+    /**
+     * Stores a value in the specified storage.
+     *
+     * @param key - The key to store the value under
+     * @param value - The value to store (will be JSON stringified)
+     * @param storage - The storage type ('local', 'session', or 'memory'). Defaults to 'session'
+     *
+     * @remarks
+     * Values are automatically JSON stringified before storage.
+     */
+    set(key: string, value: any, storage?: StorageType): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Storage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Storage>;
+}
+
+/**
+ * Utility service for string operations.
+ *
+ * @remarks
+ * Provides helper methods for common string manipulation and formatting tasks.
+ */
+declare class StringUtil {
+    /**
+     * Decodes HTML entities in a string.
+     *
+     * @param text - The string containing HTML entities to decode
+     * @returns The decoded string
+     *
+     * @example
+     * ```typescript
+     * const encoded = '&lt;div&gt;Hello&lt;/div&gt;';
+     * const decoded = stringUtil.decodeHTML(encoded);
+     * // Returns: '<div>Hello</div>'
+     * ```
+     */
+    decodeHTML(text: string): string;
+    /**
+     * Normalizes a text by converting to lowercase and removing accents.
+     *
+     * @param text - The text to normalize
+     * @returns The normalized text without accents and in lowercase
+     *
+     * @example
+     * ```typescript
+     * const normalized = stringUtil.normalize('Café');
+     * // Returns: 'cafe'
+     * ```
+     */
+    normalize(text: string): string;
+    /**
+     * Normalizes a name by trimming whitespace and capitalizing the first letter.
+     *
+     * @param text - The name text to normalize
+     * @returns The normalized name with first letter capitalized
+     *
+     * @example
+     * ```typescript
+     * const normalized = stringUtil.normalizeName('  john doe  ');
+     * // Returns: 'John doe'
+     * ```
+     */
+    normalizeName(text: string): string;
+    /**
+     * Calculates the estimated reading time in milliseconds for a given text.
+     *
+     * @param text - The text to calculate reading time for
+     * @returns The estimated reading time in milliseconds
+     *
+     * @remarks
+     * Uses a reading speed of 1200 characters per minute.
+     *
+     * @example
+     * ```typescript
+     * const readingTime = stringUtil.calculateReadingTime('Long text here...');
+     * // Returns: estimated milliseconds
+     * ```
+     */
+    calculateReadingTime(text: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StringUtil, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StringUtil>;
+}
+
+/**
+ * Service for integrating Google Tag Manager (GTM) tracking.
+ *
+ * @remarks
+ * Handles GTM script injection, variable tracking, and automatic route change tracking.
+ *
+ * @example
+ * ```typescript
+ * const gtm = inject(GoogleTagManager);
+ * gtm.appendTrackingCode('GTM-XXXXXXX');
+ * gtm.addVariable({ event: 'customEvent', data: 'value' });
+ * ```
+ */
+declare class GoogleTagManager {
+    trackingId: string;
+    private readonly platformId;
+    readonly router: Router;
+    /**
+     * Appends Google Tag Manager tracking code to the page.
+     *
+     * @param trackingId - The GTM container ID (e.g., 'GTM-XXXXXXX')
+     * @param options - Optional configuration for GTM environment
+     * @param options.environment - Environment configuration for preview mode
+     * @param options.environment.auth - Authentication token for preview
+     * @param options.environment.preview - Preview container ID
+     *
+     * @remarks
+     * Automatically subscribes to router navigation events for page view tracking.
+     */
+    appendTrackingCode(trackingId: string, options?: {
+        environment?: {
+            auth: string;
+            preview: string;
+        };
+    }): void;
+    /**
+     * Pushes a variable or event to the GTM dataLayer.
+     *
+     * @param variable - The variable or event object to push to dataLayer
+     *
+     * @example
+     * ```typescript
+     * gtm.addVariable({ event: 'purchase', value: 100 });
+     * ```
+     */
+    addVariable(variable: any): void;
+    /**
+     * Initializes router event subscribers for automatic page view tracking.
+     *
+     * @private
+     */
+    private initSubscribers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleTagManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GoogleTagManager>;
+}
+
+/**
+ * Error object structure for application error handling.
+ */
+interface Error {
+    /** Optional error code */
+    code?: number;
+    /** Optional icon identifier for error display */
+    icon?: string;
+    /** Optional error title */
+    title?: string;
+    /** Error message (required) */
+    message: string;
+}
+
+/**
+ * Constants for CRUD operation types.
+ */
+declare const OPERATION_TYPE: {
+    /** Create operation */
+    readonly CREATE: "create";
+    /** Update operation */
+    readonly UPDATE: "update";
+    /** Delete operation */
+    readonly DELETE: "delete";
+};
+/**
+ * Type representing valid operation types.
+ */
+type OperationType = (typeof OPERATION_TYPE)[keyof typeof OPERATION_TYPE];
+
+/**
+ * Represents a CRUD operation on an entity.
+ */
+interface Operation {
+    /** The type of operation (create, update, delete) */
+    method: OperationType;
+    /** The entity data for the operation */
+    entity: any;
+}
+
+/**
+ * Default configuration constants for CSV export operations.
+ */
+declare const CSV_CONFIG: {
+    /** End of line character for CSV */
+    readonly EOL: "\r\n";
+    /** Byte Order Mark for UTF-8 encoding */
+    readonly BOM: "";
+    /** Default field separator character */
+    readonly DEFAULT_FIELD_SEPARATOR: ",";
+    /** Default decimal separator */
+    readonly DEFAULT_DECIMAL_SEPARATOR: ".";
+    /** Default quote character for strings */
+    readonly DEFAULT_QUOTE: "\"";
+    /** Default value for showing title */
+    readonly DEFAULT_SHOW_TITLE: false;
+    /** Default title text */
+    readonly DEFAULT_TITLE: "My Generated Report";
+    /** Default filename (without extension) */
+    readonly DEFAULT_FILENAME: "generated";
+    /** Default value for showing column labels */
+    readonly DEFAULT_SHOW_LABELS: false;
+    /** Default value for using text file format */
+    readonly DEFAULT_USE_TEXT_FILE: false;
+    /** Default value for including BOM */
+    readonly DEFAULT_USE_BOM: true;
+    /** Default header array (empty) */
+    readonly DEFAULT_HEADER: readonly [];
+    /** Default value for using object keys as headers */
+    readonly DEFAULT_KEYS_AS_HEADERS: false;
+};
+/**
+ * Type representing valid CSV configuration values.
+ */
+type CsvConfig = (typeof CSV_CONFIG)[keyof typeof CSV_CONFIG];
+
+/**
+ * Creates a validator function for Ecuadorian identification numbers (cédula or RUC).
+ *
+ * @param type - The type of identification to validate
+ *   - 'cedula': Validates cédula (10 digits)
+ *   - 'ruc_natural': Validates RUC for natural persons (13 digits)
+ *   - 'ruc_privada': Validates RUC for private companies (13 digits)
+ *   - 'ruc_publica': Validates RUC for public companies (13 digits)
+ *   - 'ruc': Validates any type of RUC
+ *   - 'id': Validates any valid identification type
+ * @returns A validator function that returns an error object if validation fails
+ *
+ * @example
+ * ```typescript
+ * const control = new FormControl('', [identificationValidator('cedula')]);
+ * ```
+ */
+declare function identificationValidator(type: 'cedula' | 'ruc_natural' | 'ruc_privada' | 'ruc_publica' | 'ruc' | 'id'): ValidatorFn;
+
+/**
+ * Determines the type of Ecuadorian identification number.
+ *
+ * @param number - The identification number to analyze
+ * @returns The identification type ('cedula', 'ruc_natural', 'ruc_privada', 'ruc_publica') or null if invalid
+ *
+ * @example
+ * ```typescript
+ * const type = getIdentificationType('1234567890');
+ * // Returns: 'cedula' or null
+ * ```
+ */
+declare function getIdentificationType(number: string): string | null;
+
+interface User {
+    username: string;
+    roles: string[];
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    picture?: string;
+}
+
+interface Login {
+    username: string;
+    password: string;
+}
+
+declare abstract class AuthProvider {
+    abstract user: Signal<User | null>;
+    abstract login(data?: Login): Promise<boolean>;
+    abstract logout(): Promise<boolean>;
+    abstract isLoggedIn: Signal<boolean>;
+}
+
+interface AuthToken {
+    token: string;
+    refresh_token: string;
+}
+
+interface Signup {
+    firstname: string;
+    lastname: string;
+    email: string;
+    username: string;
+    password: string;
+}
+
+/**
+ * Concrete authentication provider responsible for handling session lifecycle,
+ * secure token refresh, and profile management concerns across the app.
+ *
+ * @remarks
+ * The service extends {@link AuthProvider} to leverage core session helpers while
+ * adding stateful logic for dialogs, social login, and settings synchronization.
+ */
+declare class AuthService extends AuthProvider {
+    private readonly config;
+    private readonly dialog;
+    private readonly httpClient;
+    private readonly _user;
+    /** Session token key */
+    private readonly TOKEN_KEY;
+    readonly user: i0.Signal<User | null>;
+    constructor();
+    /**
+     * Flag indicating whether the access token is being refreshed
+     */
+    refreshTokenInProgress: boolean;
+    /**
+     * Manages the access token refresh flow
+     */
+    private readonly refreshTokenSubject;
+    /**
+     * Sends the authentication token to the server
+     * @param request HTTP request
+     * @returns
+     */
+    addAuthenticationToken(request: HttpRequest<any>): HttpRequest<any>;
+    connect(client: 'google'): Promise<boolean>;
+    /**
+     * Extracts user claims from a JWT token payload.
+     * Maps common JWT claims (sub, email, given_name, family_name, etc.) to the User model.
+     * @param jwtToken The JWT token string
+     * @returns User object or null if parsing fails
+     */
+    private extractUserFromToken;
+    /**
+     * Extracts the expiration timestamp from a JWT token
+     * @param jwtToken The JWT token string
+     * @returns The expiration timestamp in seconds (JWT exp format) or undefined if not found/invalid
+     */
+    private extractExpirationFromToken;
+    /**
+     * Handles the flow of refreshing the access token or redirecting to sign-in
+     * @param err HTTP error
+     * @param request HTTP request sent
+     * @param next HTTP handler
+     */
+    handle401Error(err: HttpErrorResponse, request: HttpRequest<any>, next: HttpHandlerFn): Observable<any>;
+    /**
+     * Sends sign-in to the server and obtains the authentication token
+     * @param data Authentication data
+     * @returns
+     */
+    login(data?: Login): Promise<boolean>;
+    /**
+     * Logs out the user
+     */
+    logout(): Promise<boolean>;
+    signup(data: Signup | Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * If a refresh token is implemented, send it to obtain a new access token
+     * @returns Access token
+     */
+    refreshToken(): Observable<AuthToken>;
+    /**
+     * Reads the session token from the Secure cookie (client-side storage).
+     * @internal
+     */
+    private getToken;
+    /**
+     * Sets the authentication token in session state and in a Secure cookie (client-side).
+     * Cookie: Path=/; SameSite=Strict; Secure on HTTPS; Max-Age from expiresAt or 1 day.
+     *
+     * @param token - The authentication token object to store
+     */
+    private setToken;
+    /**
+     * Clears the authentication token from session state and removes the cookie.
+     */
+    clearToken(): void;
+    /**
+     * Clears the current user from session state
+     */
+    clearUser(): void;
+    /**
+     * Computed signal indicating whether a user is currently logged in
+     * Based on the presence and validity of the authentication token
+     *
+     * For JWT tokens, validates expiration. For other token types, only checks existence.
+     *
+     * @returns true if a valid token exists, false otherwise
+     */
+    readonly isLoggedIn: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}
+
+/**
+ * Configuration required by auth-core services.
+ * Provided via AUTH_CONFIG injection token from app.config.
+ */
+interface AuthConfig {
+    sessionPrefix: string;
+    appPath: string;
+    auth: {
+        signinUrl: string;
+        signupUrl: string;
+        refreshTokenUrl: string;
+        tokenType: string;
+        clients: Record<string, string>;
+    };
+    fedcm?: Record<string, {
+        tokenUrl: string;
+        configURL: string;
+        clientId: string;
+    }>;
+}
+
+/**
+ * Injection token for auth configuration.
+ * Provide this in app.config with values from environment.
+ *
+ * @example
+ * ```typescript
+ * import { AUTH_CONFIG } from 'auth-core';
+ * import { environment } from '@/environments/environment';
+ *
+ * providers: [
+ *   { provide: AUTH_CONFIG, useValue: environment }
+ * ]
+ * ```
+ */
+declare const AUTH_CONFIG: InjectionToken<AuthConfig>;
+
+declare const authGuard: CanActivateFn;
+declare const loginGuard: CanActivateFn;
+declare const resetGuard: CanActivateFn;
+
+declare const authInterceptor: HttpInterceptorFn;
+
+/**
+ * Base interface for JWT token payloads.
+ * Use JWTTokenPayload for the standard JWT claims implementation.
+ */
+interface AuthTokenPayload {
+    iss?: string;
+    sub?: string;
+    aud?: string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+    username?: string;
+    roles?: string[];
+    permissions?: string[];
+    [key: string]: unknown;
+}
+
+interface FedcmCredentialRequestOptions extends CredentialRequestOptions {
+    identity: {
+        providers: {
+            configURL: string;
+            clientId: string;
+            fields: string[];
+            params: any;
+            nonce: string;
+        }[];
+        mode: string;
+    };
+}
+interface FedcmCredential {
+    token: string;
+}
+
+interface JwtAuthProvider {
+    getTokenPayload<T = AuthTokenPayload>(): T | null;
+}
+
+interface JWTTokenPayload {
+    iss?: string;
+    sub?: string;
+    aud?: string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+    username?: string;
+    roles?: string[];
+    permissions?: string[];
+    [key: string]: unknown;
+}
+
+export { AUTH_CONFIG, ArrayUtil, AuthProvider, AuthService, CSV_CONFIG, ColorUtil, CsvExporter, DateUtil, FilePicker, GoogleTagManager, OPERATION_TYPE, ObjectUtil, Storage, StringUtil, authGuard, authInterceptor, getIdentificationType, identificationValidator, loginGuard, resetGuard };
+export type { AuthConfig, AuthToken, AuthTokenPayload, CsvConfig, CsvOptions, CsvParsed, Error, FedcmCredential, FedcmCredentialRequestOptions, JWTTokenPayload, JwtAuthProvider, Login, Operation, OperationType, Signup, User };