@sdcorejs/angular 19.0.1 → 20.0.0

package/pipes/index.d.ts

@@ -1,4 +1,43 @@
-export * from './src/format-number.pipe';
-export * from './src/safe-html.pipe';
-export * from './src/time-different.pipe';
-export * from './src/empty.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { ISdCoreConfiguration } from '@sdcorejs/angular/configurations';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+
+declare class SdFormatNumberPipe implements PipeTransform {
+    private readonly coreConfiguration;
+    constructor(coreConfiguration: ISdCoreConfiguration | undefined);
+    transform(value: any, digits?: number, format?: '1,234,567.89' | '1.234.567,89'): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdFormatNumberPipe, [{ optional: true; }]>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdFormatNumberPipe, "sdFormatNumber", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdFormatNumberPipe>;
+}
+
+declare class SdSafeHtmlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(html: string | number | undefined | null): _angular_platform_browser.SafeHtml | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdSafeHtmlPipe, "sdSafeHtml", true>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdSafeHtmlPipe>;
+}
+
+declare class SdTimeDifferentPipe implements PipeTransform {
+    private maxSecond;
+    private maxMinute;
+    private maxHour;
+    private maxDay;
+    private maxMonth;
+    transform(value: any, format: string, different: 'second' | 'minute' | 'hour' | 'day' | 'month'): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTimeDifferentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdTimeDifferentPipe, "sdTimeDifferent", true>;
+}
+
+declare class SdEmptyPipe implements PipeTransform {
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdEmptyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdEmptyPipe, "sdEmpty", true>;
+}
+
+export { SdEmptyPipe, SdFormatNumberPipe, SdSafeHtmlPipe, SdTimeDifferentPipe };

package/services/api/index.d.ts

@@ -1,4 +1,71 @@
-export * from './src/api.model';
-export * from './src/api.service';
-export * from './src/interceptors/api.interceptor';
-export * from './src/api.module';
+import { HttpRequest, HttpResponse, HttpErrorResponse, HttpClient, HttpInterceptor, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { SdCacheOption } from '@sdcorejs/angular/services/cache';
+import { Observable } from 'rxjs';
+
+interface SdApiOption {
+    cacheOption?: SdCacheOption;
+    timeout?: number;
+    autoCache?: boolean;
+}
+type HttpGetOption = Parameters<HttpClient['get']>[1];
+type SdGetOption = HttpGetOption & SdApiOption;
+type HttpPostOption = Parameters<HttpClient['post']>[2];
+type SdPostOption = HttpPostOption & SdApiOption;
+type HttpPutOption = Parameters<HttpClient['put']>[2];
+type SdPutOption = HttpPutOption & SdApiOption;
+type HttpDeleteOption = Parameters<HttpClient['delete']>[1];
+type SdDeleteOption = HttpDeleteOption & SdApiOption;
+interface SdApiHandler {
+    /** Danh sách host URL mà handler này sẽ xử lý */
+    hosts: string[];
+    /** Can thiệp request: gắn header, token, transform body... */
+    intercept?: (request: HttpRequest<any>) => HttpRequest<any>;
+    /** Hook chạy TRƯỚC khi gửi request (dùng để log, tracking...) */
+    beforeRemote?: (request: HttpRequest<any>) => void | Promise<void>;
+    /** Hook chạy SAU khi nhận response (xử lý lỗi, notify...) */
+    afterRemote?: (response: HttpResponse<any> | HttpErrorResponse | Error) => void | Promise<void>;
+    /** Transform response body thành kiểu dữ liệu mong muốn */
+    mapResponse?: <Tres = any, Tdata = any>(response: Tres) => Tdata;
+    /** Timeout tính bằng milliseconds. Mặc định: 30000 (30 giây) */
+    timeout?: number;
+}
+interface ISdApiConfiguration {
+    handlers: SdApiHandler[];
+}
+declare const SD_API_CONFIG: InjectionToken<ISdApiConfiguration>;
+declare const SD_API_CONFIGURATION: InjectionToken<ISdApiConfiguration>;
+
+declare class SdApiService {
+    #private;
+    constructor();
+    get http(): HttpClient;
+    get: <T = any>(url: string, option?: SdGetOption) => Promise<T>;
+    post: <T = any>(url: string, body?: any, option?: SdPostOption) => Promise<T>;
+    put: <T = any>(url: string, body?: any, option?: SdPutOption) => Promise<T>;
+    delete: <T = any>(url: string, option?: SdDeleteOption) => Promise<T>;
+    upload: (url: string, option?: {
+        extensions?: string[];
+        maxSizeInMb?: number;
+    }) => Promise<any>;
+    uploadFile: (url: string, file: File) => Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdApiService>;
+}
+
+declare class SdHttpInterceptor implements HttpInterceptor {
+    #private;
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdHttpInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdHttpInterceptor>;
+}
+
+declare class SdApiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdApiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SdApiModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SdApiModule>;
+}
+
+export { SD_API_CONFIG, SD_API_CONFIGURATION, SdApiModule, SdApiService, SdHttpInterceptor };
+export type { ISdApiConfiguration, SdApiHandler, SdApiOption, SdDeleteOption, SdGetOption, SdPostOption, SdPutOption };

package/services/cache/index.d.ts

@@ -1,2 +1,43 @@
-export * from './src/cache.service';
-export * from './src/cache.model';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+
+interface SdCacheOption<T = any> {
+    type?: 'memory' | 'session' | 'local';
+    hours?: number;
+    default?: T;
+    args?: Record<string, any>;
+}
+interface SdCache<T = any> {
+    get: () => T;
+    set: (data: T) => void;
+    has: () => boolean;
+    remove: () => void;
+    destroy: () => void;
+    observer: Observable<T | undefined>;
+    load: (callback: () => Promise<T>) => Promise<T>;
+}
+interface ISdCacheConfiguration {
+    convertKey?: (key: string) => string;
+    set?: (key: string, value: {
+        data: any;
+        createdOn: Date;
+    }, option?: SdCacheOption) => Promise<void>;
+    get?: (key: string, option?: SdCacheOption) => Promise<{
+        data: any;
+        createdOn: Date;
+    }>;
+    remove?: (key: string, option?: SdCacheOption) => Promise<void>;
+}
+declare const SD_CACHE_CONFIG: InjectionToken<ISdCacheConfiguration>;
+
+declare class SdCacheService {
+    #private;
+    constructor();
+    create<T = any>(key: string | object, option?: SdCacheOption<T>): SdCache<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdCacheService>;
+}
+
+export { SD_CACHE_CONFIG, SdCacheService };
+export type { ISdCacheConfiguration, SdCache, SdCacheOption };

package/services/confirm/index.d.ts

@@ -1 +1,103 @@
-export * from './src/public-api';
+import { MatDialogRef, MatDialog } from '@angular/material/dialog';
+import { Color } from '@sdcorejs/utils/models';
+import * as i0 from '@angular/core';
+
+interface DialogData {
+    icon?: string;
+    title?: string;
+    message?: string;
+    yesTitle?: string;
+    noTitle?: string;
+    yesButtonColor?: Color;
+    noButtonColor?: Color;
+    input?: {
+        placeholder?: string;
+        minlength?: number;
+        maxlength?: number;
+        required?: boolean;
+        defaultValue?: string;
+    };
+    date?: {
+        required?: boolean;
+        placeholder?: string;
+        defaultValue?: string | Date;
+        min?: string | Date;
+        max?: string | Date;
+    };
+    radio?: {
+        required?: boolean;
+        defaultValue?: string | number;
+        items: any[];
+        valueField: string;
+        displayField: string;
+        display?: 'row' | 'column';
+    };
+}
+declare class DialogConfirmComponent {
+    dialogRef: MatDialogRef<DialogConfirmComponent>;
+    data: DialogData;
+    value: any;
+    required: boolean;
+    id: string;
+    constructor(dialogRef: MatDialogRef<DialogConfirmComponent>, data: DialogData);
+    onCancel: () => void;
+    onAccept: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogConfirmComponent, "sd-dialog-confirm", never, {}, {}, never, never, true, never>;
+}
+
+declare class SdConfirmService {
+    #private;
+    private dialog;
+    constructor(dialog: MatDialog);
+    confirm: (message: string, option?: {
+        title?: string;
+        yesTitle?: string;
+        noTitle?: string;
+        yesButtonColor?: Color;
+        noButtonColor?: Color;
+        width?: string;
+        disableBackdropClose?: boolean;
+    }) => Promise<unknown>;
+    withInput: (message?: string, option?: {
+        title?: string;
+        yesTitle?: string;
+        noTitle?: string;
+        required?: boolean;
+        maxlength?: number;
+        yesButtonColor?: Color;
+        noButtonColor?: Color;
+        defaultValue?: string;
+        disableBackdropClose?: boolean;
+    }) => Promise<string>;
+    withRadio: (message?: string, option?: {
+        title?: string;
+        yesTitle?: string;
+        noTitle?: string;
+        required?: boolean;
+        yesButtonColor?: Color;
+        noButtonColor?: Color;
+        defaultValue?: string | number;
+        items: any[];
+        valueField: string;
+        displayField: string;
+        display?: "row" | "column";
+        disableBackdropClose?: boolean;
+    }) => Promise<string>;
+    withDate: (message?: string, option?: {
+        title?: string;
+        yesTitle?: string;
+        noTitle?: string;
+        required?: boolean;
+        yesButtonColor?: Color;
+        noButtonColor?: Color;
+        defaultValue?: string | Date;
+        placeholder?: string;
+        disableBackdropClose?: boolean;
+    }) => Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdConfirmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdConfirmService>;
+}
+
+export { DialogConfirmComponent, SdConfirmService };
+export type { DialogData };

package/services/docx/index.d.ts

@@ -1 +1,28 @@
-export * from './src/public-api';
+import { SdNotifyService } from '@sdcorejs/angular/services/notify';
+import { SdLoadingService } from '@sdcorejs/angular/services/loading';
+import * as i0 from '@angular/core';
+
+interface SdDocxConvertOptions {
+    validateFormat?: boolean;
+    validateSize?: boolean;
+    maxSizeInMb?: number;
+}
+interface SdDocxConvertResult {
+    html: string;
+    messages: string[];
+}
+
+declare class SdDocxService {
+    #private;
+    private notifyService;
+    private loadingService;
+    constructor(notifyService: SdNotifyService, loadingService: SdLoadingService);
+    open(options?: SdDocxConvertOptions): Promise<SdDocxConvertResult | null>;
+    convertToHtml(input: File | Blob | ArrayBuffer, options?: SdDocxConvertOptions): Promise<SdDocxConvertResult | null>;
+    convertToHtmlString(input: File | Blob | ArrayBuffer, options?: SdDocxConvertOptions): Promise<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdDocxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdDocxService>;
+}
+
+export { SdDocxService };
+export type { SdDocxConvertOptions, SdDocxConvertResult };

package/services/excel/index.d.ts

@@ -1 +1,54 @@
-export * from './src/public-api';
+import * as i0 from '@angular/core';
+
+interface SdExcelTemplate {
+    fileName?: string;
+    columns: SdExcelTemplateColumn[];
+    sheets?: SdExcelSheet[];
+}
+interface SdExcelColumn {
+    field: string;
+    title: string;
+    description?: string;
+    width?: string;
+}
+interface SdExcelTemplateColumn extends SdExcelColumn {
+    required?: boolean;
+    color?: string;
+    fontColor?: string;
+    fill?: string;
+}
+interface SdExcelSheet<T = any> {
+    name: string;
+    items: T[];
+    headers: {
+        value: Extract<keyof T, string>;
+        display: string;
+    }[];
+}
+interface SdExcelExportOption<T = any> {
+    columns: SdExcelTemplateColumn[];
+    items: T[];
+    fileName?: string;
+    sheets?: SdExcelSheet[];
+}
+
+declare class SdExcelService {
+    #private;
+    constructor();
+    generateTemplate: (template: SdExcelTemplate) => Promise<void>;
+    exportCSV: (option: SdExcelExportOption) => Promise<void>;
+    export: (option: SdExcelExportOption) => Promise<void>;
+    upload: () => Promise<{
+        items: Record<string, any>[];
+        file: File | null;
+    }>;
+    parse: (file: File) => Promise<{
+        items: Record<string, any>[];
+        file: File | null;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdExcelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdExcelService>;
+}
+
+export { SdExcelService };
+export type { SdExcelColumn, SdExcelExportOption, SdExcelSheet, SdExcelTemplate, SdExcelTemplateColumn };

package/services/license/index.d.ts

@@ -1 +1,13 @@
-export * from './src/license.service';
+import { ISdCoreConfiguration } from '@sdcorejs/angular/configurations';
+import * as i0 from '@angular/core';
+
+declare class SdLicenseService {
+    #private;
+    private readonly coreConfiguration;
+    constructor(coreConfiguration: ISdCoreConfiguration | undefined);
+    enforceLicense: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdLicenseService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdLicenseService>;
+}
+
+export { SdLicenseService };

package/services/loading/index.d.ts

@@ -1 +1,17 @@
-export * from './src/loading.service';
+import * as i0 from '@angular/core';
+import { RendererFactory2 } from '@angular/core';
+
+declare class SdLoadingService {
+    #private;
+    private loadingId;
+    private renderer;
+    private loadingMap;
+    constructor(rendererFactory: RendererFactory2);
+    start: (element?: string) => void;
+    isLoading: (element?: string) => boolean | null;
+    stop: (element?: string) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdLoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdLoadingService>;
+}
+
+export { SdLoadingService };

package/services/notify/index.d.ts

@@ -1,2 +1,40 @@
-export { type NotifyOption as SdNotifyOption } from './src/notify.model';
-export * from './src/notify.service';
+import * as i0 from '@angular/core';
+import { ApplicationRef, EnvironmentInjector } from '@angular/core';
+
+type ToastType = 'success' | 'info' | 'warning' | 'error';
+interface ToastData {
+    id: string;
+    type: ToastType;
+    title?: string;
+    message: string | string[];
+    duration: number;
+    actionLabel?: string;
+    onAction?: () => void;
+}
+interface NotifyOption {
+    duration?: number;
+    title?: string;
+    actionLabel?: string;
+    onAction?: () => void;
+}
+
+declare class SdNotifyService {
+    #private;
+    private appRef;
+    private injector;
+    private document;
+    readonly toasts: i0.WritableSignal<ToastData[]>;
+    constructor(appRef: ApplicationRef, injector: EnvironmentInjector, document: Document);
+    success(message: string, option?: NotifyOption): void;
+    info(message: string, option?: NotifyOption): void;
+    warning(message: string | string[], option?: NotifyOption): void;
+    error(message: string | string[], option?: NotifyOption): void;
+    remove(id: string): void;
+    clearAll(): void;
+    clearByType(type: ToastType): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdNotifyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdNotifyService>;
+}
+
+export { SdNotifyService };
+export type { NotifyOption as SdNotifyOption };

package/services/storage/index.d.ts

@@ -1,2 +1,34 @@
-export * from './src/storage.model';
-export * from './src/storage.service';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+interface SdStorageOption<T = any> {
+    type?: 'session';
+    default?: T;
+    args?: Record<string, any>;
+}
+interface SdStorage<T = any> {
+    get: () => T;
+    set: (data: T) => void;
+    setSilent: (data: T) => void;
+    has: () => boolean;
+    remove: () => void;
+    subject: BehaviorSubject<T>;
+    observer: Observable<T>;
+}
+interface ISdStorageConfiguration {
+    key?: (key: string) => string;
+}
+declare const SD_STORAGE_CONFIG: InjectionToken<ISdStorageConfiguration>;
+
+declare class SdStorageService {
+    #private;
+    private configuration;
+    constructor(configuration: ISdStorageConfiguration);
+    create<T = any>(key: string | object, option?: SdStorageOption<T>): SdStorage<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdStorageService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdStorageService>;
+}
+
+export { SD_STORAGE_CONFIG, SdStorageService };
+export type { ISdStorageConfiguration, SdStorage, SdStorageOption };

package/utilities/data-state/index.d.ts

@@ -1 +1,13 @@
-export * from './src/data-state';
+/**
+ * Serialize a value for the `data-value` attribute consumed by QA automation.
+ *
+ * null/undefined/empty-string → ''.
+ * Date → ISO string.
+ * Array / object → JSON.stringify, '' on failure (circular refs).
+ * Primitives → String().
+ */
+declare function sdSerializeDataValue(value: unknown): string;
+/** True when the value should drive `data-empty="true"` on a form control. */
+declare function sdIsEmpty(value: unknown): boolean;
+
+export { sdIsEmpty, sdSerializeDataValue };

package/utilities/extensions/index.d.ts

@@ -1,6 +1,87 @@
-export * from './src/array.extension';
-export * from './src/string.extension';
-export * from './src/number.extension';
-export * from './src/date.extension';
-export * from './src/utility.extension';
-export * from './src/color.extension';
+export { ArrayUtilities, BrowserUtilities, ColorUtilities, DateUtilities, NumberUtilities, Utilities, ValidationUtilities } from '@sdcorejs/utils/fns';
+
+declare const StringUtilities: {
+    /** @deprecated Use REGEX_VN_PHONE instead */
+    REGEX_PHONE_VN: string;
+    /** @deprecated Use REGEX_VN_ID instead */
+    REGEX_IDVN: string;
+    /** @deprecated Use REGEX_VN_ID_OR_PASSPORT instead */
+    REGEX_IDVN_OR_PASSPORT: string;
+    /** @deprecated Use {@link ValidationUtilities.isEmail} instead */
+    isValidEmail: (value: any) => boolean;
+    /** @deprecated Use {@link ValidationUtilities.isPhone} instead */
+    isValidPhone: (value: any) => boolean;
+    /** @deprecated Use {@link ValidationUtilities.isCode} instead */
+    isValidCode: (value: any) => boolean;
+    REGEX_EMAIL: string;
+    REGEX_PHONE: string;
+    REGEX_VN_PHONE: string;
+    REGEX_VN_ID: string;
+    REGEX_PASSPORT: string;
+    REGEX_VN_ID_OR_PASSPORT: string;
+    REGEX_TIME: string;
+    REGEX_URL: string;
+    REGEX_DOMAIN: string;
+    REGEX_IPV4: string;
+    REGEX_IPV6: string;
+    REGEX_IMAGE_URL: string;
+    REGEX_SLUG: string;
+    REGEX_NUMBER: string;
+    REGEX_INTEGER: string;
+    REGEX_DECIMAL: string;
+    REGEX_POSITIVE_NUMBER: string;
+    REGEX_UUID: string;
+    REGEX_CODE_16: string;
+    REGEX_CODE_32: string;
+    REGEX_HEX_COLOR: string;
+    REGEX_BASE64: string;
+    changeAliasLowerCase: (alias: any) => string;
+    aliasIncludes: (alias: any, searchText: any) => boolean;
+    format: (template: string, ...arr: any[]) => string;
+    templateToDisplay: (template: string, entity: Record<string, any>) => string;
+    parseExpression: (template: string, entity: Record<string, any>) => any;
+    encrypt: (obj: any) => string;
+    decrypt: (encripted: string) => any;
+    isNullOrEmpty: (value: any) => boolean;
+    isNullOrWhiteSpace: (value: any) => boolean;
+    convertToSnakeCaseCode: (name: string) => string;
+    generateUniqueCode: (name: string, existingCodes: string[]) => string;
+    sha256: (input: string) => Promise<string>;
+};
+
+/**
+ * @deprecated Use {@link Utilities} and {@link BrowserUtilities} from `@sdcorejs/utils/fns` instead.
+ * - upload/download/clipboard/isMobile → BrowserUtilities
+ * - allWithPaging (→ fetchAllByPaging) / randomId / hash / parseQueryParams / generateUuid / getNestedValue → Utilities
+ */
+declare const SdUtilities: {
+    upload: (option?: {
+        extensions?: string[];
+        maxSizeInMb?: number;
+        validator?: (fileName: string) => string;
+        multiple?: boolean;
+    }) => Promise<File | File[] | null>;
+    download: (fileOrPath: File | string | undefined | null, fileName?: string | null) => void;
+    downloadBlob: (blob: Blob, fileName?: string) => void;
+    changeAliasLowerCase: (alias: string) => string;
+    copyToClipboard: (text: string) => void;
+    allWithPaging: <T = unknown>(func: (pageSize: number, pageNumber: number) => Promise<{
+        items: T[];
+        total: number;
+    }>, defaultPageSize?: number) => Promise<T[]>;
+    isIncognito: () => Promise<boolean>;
+    isMobile: () => boolean;
+    randomId: (prefix?: string | null) => string;
+    hash: (obj: any) => string;
+    parseQueryParams: (queryString?: string) => Record<string, string>;
+    getClientPublicIp: () => Promise<string | null>;
+    generateUuid: () => string;
+    getNestedValue: (obj: any, path: string) => any;
+};
+
+/** @deprecated Use {@link ColorUtilities.hslToHex} from `@sdcorejs/utils/fns` instead */
+declare const hslToHex: (h: number, s: number, l: number) => string;
+/** @deprecated Use {@link ColorUtilities.rgbToHex} from `@sdcorejs/utils/fns` instead */
+declare const rgbToHex: (r: number, g: number, b: number) => string;
+
+export { SdUtilities, StringUtilities, hslToHex, rgbToHex };