@ship-ui/core 0.13.2

package/index.d.ts

@@ -0,0 +1,758 @@
+import * as _ship_ui_core from '@ship-ui/core';
+import * as _angular_core from '@angular/core';
+import { ElementRef, QueryList, ComponentRef, OutputRefSubscription, Type, AfterContentInit, TemplateRef, WritableSignal, OnDestroy, InjectionToken } from '@angular/core';
+
+type ShipAlertItem = {
+    type: ShipAlertType;
+    title: string;
+    content?: string;
+};
+type ShipAlertItemInternal = ShipAlertItem & {
+    id: string;
+    isOpen: boolean;
+    animateOut: boolean;
+    animateIn: boolean;
+};
+declare class ShipAlertService {
+    alertHistory: _angular_core.WritableSignal<ShipAlertItemInternal[]>;
+    alertHistoryIsOpen: _angular_core.WritableSignal<boolean>;
+    alertHistoryIsHidden: _angular_core.WritableSignal<boolean>;
+    error(message: string | null | undefined): void;
+    success(message: string): void;
+    question(message: string): void;
+    warning(message: string): void;
+    info(message: string): void;
+    addAlert(alert: ShipAlertItem): void;
+    removeAlert(id: string): void;
+    hideAlert(id: string): void;
+    setHidden(isHidden: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipAlertService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShipAlertService>;
+}
+
+type ShipAlertType = 'error' | 'success' | 'warn' | 'primary' | 'accent' | 'question';
+declare class ShipAlertComponent {
+    _el: ElementRef<any>;
+    alertService: _angular_core.InputSignal<ShipAlertService | null>;
+    id: _angular_core.InputSignal<string | null>;
+    alertClasses: _angular_core.Signal<any>;
+    removeAlert(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipAlertComponent, "sh-alert", never, { "alertService": { "alias": "alertService"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["[icon]", "[title]", "*", "[content]"], true, never>;
+}
+
+declare class ShipAlertContainerComponent {
+    #private;
+    inline: _angular_core.InputSignal<string | null>;
+    alerts: _angular_core.Signal<QueryList<ShipAlertComponent>>;
+    scroller: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    alertService: _angular_core.InputSignal<ShipAlertService>;
+    alertHistory: _angular_core.WritableSignal<_ship_ui_core.ShipAlertItemInternal[]>;
+    alertHistoryIsOpen: _angular_core.WritableSignal<boolean>;
+    alertHistoryIsHidden: _angular_core.WritableSignal<boolean>;
+    numberOfOpenAlerts: _angular_core.Signal<number>;
+    onMouseOver(): void;
+    onMouseOut(): void;
+    getElementHeight(i: number): number;
+    transformY(i: number): string;
+    transitionDelay(i: number, allOpen?: boolean): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipAlertContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipAlertContainerComponent, "ship-alert-container", never, { "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "alertService": { "alias": "alertService"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ShipAlertModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipAlertModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ShipAlertModule, never, [typeof ShipAlertComponent, typeof ShipAlertContainerComponent], [typeof ShipAlertComponent, typeof ShipAlertContainerComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ShipAlertModule>;
+}
+
+type ShipDialogOptions = {
+    class?: 'default' | 'type-b';
+    width?: string;
+    maxWidth?: string;
+    height?: string;
+    maxHeight?: string;
+    closeOnButton?: boolean;
+    closeOnEsc?: boolean;
+    closeOnOutsideClick?: boolean;
+};
+declare class ShipDialogComponent {
+    #private;
+    dialogRef: _angular_core.Signal<ElementRef<HTMLDialogElement> | undefined>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    options: _angular_core.InputSignal<Partial<ShipDialogOptions> | undefined>;
+    closed: _angular_core.OutputEmitterRef<void>;
+    defaultOptionMerge: _angular_core.Signal<{
+        class: string;
+        width?: string;
+        maxWidth?: string;
+        height?: string;
+        maxHeight?: string;
+        closeOnButton?: boolean;
+        closeOnEsc?: boolean;
+        closeOnOutsideClick?: boolean;
+    }>;
+    abortController: AbortController | null;
+    isOpenEffect: _angular_core.EffectRef;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipDialogComponent, "sh-dialog", never, { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+interface ShipDialogServiceOptions<T = any> extends ShipDialogOptions {
+    data?: T;
+    closed?: (...args: any[]) => void;
+}
+type ShipDialogReturn<T> = ReturnType<ShipDialogService['open']> & {
+    component: T;
+};
+declare class ShipDialogService {
+    #private;
+    compRef: ComponentRef<ShipDialogComponent> | null;
+    insertedCompRef: ComponentRef<unknown> | null;
+    closedFieldSub: OutputRefSubscription | null;
+    compClosedSub: OutputRefSubscription | null;
+    open<T, K = any>(component: Type<T>, options?: ShipDialogServiceOptions<K>): {
+        component: T;
+        close: () => void;
+    };
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShipDialogService>;
+}
+
+declare class ShipButtonGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipButtonGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipButtonGroupComponent, "sh-button-group", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipButtonComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipButtonComponent, "[shButton]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipCardComponent {
+    #private;
+    class: _angular_core.WritableSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipCardComponent, "sh-card", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipCheckboxComponent {
+    #private;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipCheckboxComponent, "sh-checkbox", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipChipComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipChipComponent, "sh-chip", never, {}, {}, never, ["*"], true, never>;
+}
+
+type R = number;
+type G = number;
+type B = number;
+declare class ShipColorPickerComponent {
+    readonly canvasRef: _angular_core.Signal<ElementRef<HTMLCanvasElement>>;
+    private canvasData;
+    showDarkColors: _angular_core.InputSignal<boolean>;
+    renderingType: _angular_core.InputSignal<"hsl" | "grid" | "hue" | "rgb" | "saturation">;
+    gridSize: _angular_core.InputSignal<number>;
+    hue: _angular_core.InputSignal<number>;
+    direction: _angular_core.InputSignal<"horizontal" | "vertical">;
+    selectedColor: _angular_core.ModelSignal<[number, number, number]>;
+    currentColor: _angular_core.OutputEmitterRef<{
+        rgb: string;
+        hex: string;
+        hsl: string;
+        hue: number;
+        saturation: number;
+    }>;
+    centerLightness: _angular_core.Signal<200 | 100>;
+    isDragging: _angular_core.WritableSignal<boolean>;
+    markerPosition: _angular_core.WritableSignal<{
+        x: string;
+        y: string;
+    }>;
+    _pos: {
+        x: string;
+        y: string;
+    };
+    _markerPosition: _angular_core.EffectRef;
+    selectedColorRgb: _angular_core.Signal<string>;
+    selectedColorHex: _angular_core.Signal<string>;
+    selectedColorHsl: _angular_core.Signal<string>;
+    selectedColorEffect: _angular_core.EffectRef;
+    onResize(): void;
+    private renderingTypeEffect;
+    initColor: [R, G, B] | null;
+    ngAfterViewInit(): void;
+    private updateMarkerFromColor;
+    private findPositionByColor;
+    private adjustMarkerPosition;
+    private initCanvasEvents;
+    private setCanvasSize;
+    private updateColorAndMarker;
+    private drawColorPicker;
+    private drawRgb;
+    private drawSaturation;
+    private drawHue;
+    private drawColorWheel;
+    private drawGrid;
+    private rgbToHex;
+    private rgbToHsl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipColorPickerComponent, "sh-color-picker", never, { "showDarkColors": { "alias": "showDarkColors"; "required": false; "isSignal": true; }; "renderingType": { "alias": "renderingType"; "required": false; "isSignal": true; }; "gridSize": { "alias": "gridSize"; "required": false; "isSignal": true; }; "hue": { "alias": "hue"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "selectedColor": { "alias": "selectedColor"; "required": false; "isSignal": true; }; }, { "selectedColor": "selectedColorChange"; "currentColor": "currentColor"; }, never, never, true, never>;
+}
+
+declare class ShipDatepickerInputComponent {
+    #private;
+    inputWrapRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    masking: _angular_core.InputSignal<string>;
+    closed: _angular_core.OutputEmitterRef<Date | null>;
+    _maskedDate: _angular_core.Signal<string | Date | null>;
+    internalDate: _angular_core.WritableSignal<Date | null>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    styleClasses: _angular_core.WritableSignal<null>;
+    onDateChange(date: Date | null): void;
+    open($event: MouseEvent): void;
+    close(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipDatepickerInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipDatepickerInputComponent, "sh-datepicker-input", never, { "masking": { "alias": "masking"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "isOpen": "isOpenChange"; }, never, ["label", "[prefix]", "[textPrefix]", "input", "[textSuffix]", "[suffix]"], true, never>;
+}
+
+declare class ShipDatepickerComponent {
+    #private;
+    date: _angular_core.ModelSignal<Date | null>;
+    endDate: _angular_core.ModelSignal<Date | null>;
+    asRange: _angular_core.InputSignal<boolean>;
+    monthsToShow: _angular_core.InputSignal<number>;
+    disabled: _angular_core.InputSignal<boolean>;
+    startOfWeek: _angular_core.InputSignal<number>;
+    weekdayLabels: _angular_core.InputSignal<string[]>;
+    daysRef: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    currentDate: _angular_core.WritableSignal<Date>;
+    monthOffsets: _angular_core.Signal<number[]>;
+    selectedDateStylePosition: _angular_core.WritableSignal<{
+        transform: string;
+        opacity: string;
+    } | null>;
+    weekdays: _angular_core.Signal<string[]>;
+    getLastVisibleMonth(): Date;
+    getOffsetDate(monthOffset: number): Date;
+    getMonthDates(monthOffset: number): Date[];
+    ngOnInit(): void;
+    nextMonth(): void;
+    previousMonth(): void;
+    setDate(newDate: Date, selectedElement: HTMLDivElement): void;
+    isDateSelected(date: Date): string | null;
+    setSelectedDateStylePosition(selectedElement: HTMLDivElement): void;
+    getMonthName(date: Date): string;
+    getFullYear(date: Date): number;
+    isCurrentMonth(date: Date, monthOffset: number): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipDatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipDatepickerComponent, "sh-datepicker", never, { "date": { "alias": "date"; "required": false; "isSignal": true; }; "endDate": { "alias": "endDate"; "required": false; "isSignal": true; }; "asRange": { "alias": "asRange"; "required": false; "isSignal": true; }; "monthsToShow": { "alias": "monthsToShow"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "startOfWeek": { "alias": "startOfWeek"; "required": false; "isSignal": true; }; "weekdayLabels": { "alias": "weekdayLabels"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; "endDate": "endDateChange"; }, never, never, true, never>;
+}
+
+declare class ShipDaterangeInputComponent {
+    #private;
+    startDateInputs: _angular_core.Signal<readonly ElementRef<HTMLInputElement>[]>;
+    endDateInputs: _angular_core.Signal<readonly ElementRef<HTMLInputElement>[]>;
+    monthsToShow: _angular_core.InputSignal<number>;
+    masking: _angular_core.InputSignal<string>;
+    closed: _angular_core.OutputEmitterRef<{
+        start: Date | null;
+        end: Date | null;
+    }>;
+    startDate: _angular_core.WritableSignal<Date | null>;
+    endDate: _angular_core.WritableSignal<Date | null>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    get classes(): string;
+    _maskedStartDate: _angular_core.Signal<string | null>;
+    _maskedEndDate: _angular_core.Signal<string | null>;
+    constructor();
+    private setupInput;
+    onStartDateChange(date: Date | null): void;
+    onEndDateChange(date: Date | null): void;
+    private updateInputValue;
+    private dispatchInputEvent;
+    open($event: MouseEvent): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipDaterangeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipDaterangeInputComponent, "sh-daterange-input", never, { "monthsToShow": { "alias": "monthsToShow"; "required": false; "isSignal": true; }; "masking": { "alias": "masking"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "isOpen": "isOpenChange"; }, ["startDateInputs", "endDateInputs"], ["label", "[prefix]", "[textPrefix]", "input", "[textSuffix]", "[suffix]"], true, never>;
+}
+
+declare class ShipDividerComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipDividerComponent, "sh-divider", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipFileUploadComponent {
+    _el: ElementRef<any>;
+    inputRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    filesOver: _angular_core.WritableSignal<boolean>;
+    multiple: _angular_core.InputSignal<boolean | null | undefined>;
+    accept: _angular_core.InputSignal<string | null>;
+    placeholder: _angular_core.ModelSignal<string>;
+    overlayText: _angular_core.InputSignal<string>;
+    files: _angular_core.ModelSignal<File[]>;
+    fileUploadClasses: _angular_core.Signal<any>;
+    handleFileUpload(newFiles: File[]): void;
+    inputEffect: _angular_core.EffectRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipFileUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipFileUploadComponent, "sh-file-upload", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "overlayText": { "alias": "overlayText"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, { "placeholder": "placeholderChange"; "files": "filesChange"; }, never, ["label"], true, never>;
+}
+
+declare class ShipFormFieldComponent {
+    #private;
+    onClick(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipFormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipFormFieldComponent, "sh-form-field", never, {}, {}, never, ["label", "[prefix]", "[textPrefix]", "input", "textarea", "[textSuffix]", "[suffix]", "[error]", "[hint]"], true, never>;
+}
+
+declare class ShipIconComponent implements AfterContentInit {
+    #private;
+    ngAfterContentInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipIconComponent, "sh-icon", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipListComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipListComponent, "sh-list", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipMenuComponent {
+    #private;
+    asMultiLayer: _angular_core.InputSignal<boolean>;
+    openIndicator: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    customOptionElementSelectors: _angular_core.InputSignal<string[]>;
+    keepClickedOptionActive: _angular_core.InputSignal<boolean>;
+    closeOnClick: _angular_core.InputSignal<boolean>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    closed: _angular_core.OutputEmitterRef<boolean>;
+    searchable: _angular_core.InputSignal<boolean>;
+    activeOptionIndex: _angular_core.WritableSignal<number>;
+    inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    optionsRef: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    options: {
+        signal: _angular_core.Signal<HTMLButtonElement[]>;
+        destroy: () => void;
+    };
+    optionsEl: _angular_core.Signal<HTMLButtonElement[]>;
+    inputValue: _angular_core.WritableSignal<string | null | undefined>;
+    abortController: AbortController | null;
+    optionsEffect: _angular_core.EffectRef;
+    _lastElementList: HTMLButtonElement[];
+    activeElements: _angular_core.WritableSignal<HTMLButtonElement[]>;
+    lastInputValue: string;
+    inputValueEffect: _angular_core.EffectRef;
+    activeOptionIndexEffect: _angular_core.EffectRef;
+    nextActiveIndex(activeIndex: number): number;
+    prevActiveIndex(activeIndex: number): number;
+    close(action?: 'fromPopover' | 'closed' | 'active', event?: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipMenuComponent, "sh-menu", never, { "asMultiLayer": { "alias": "asMultiLayer"; "required": false; "isSignal": true; }; "openIndicator": { "alias": "openIndicator"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "customOptionElementSelectors": { "alias": "customOptionElementSelectors"; "required": false; "isSignal": true; }; "keepClickedOptionActive": { "alias": "keepClickedOptionActive"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closed": "closed"; }, never, ["*", "[menu]"], true, never>;
+}
+
+type ShipPopoverOptions = {
+    width?: string;
+    height?: string;
+    closeOnButton?: boolean;
+    closeOnEsc?: boolean;
+};
+declare class ShipPopoverComponent {
+    #private;
+    SUPPORTS_ANCHOR: boolean;
+    asMultiLayer: _angular_core.InputSignal<boolean>;
+    disableOpenByClick: _angular_core.InputSignal<boolean>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    options: _angular_core.InputSignal<Partial<ShipPopoverOptions> | undefined>;
+    closed: _angular_core.OutputEmitterRef<void>;
+    defaultOptionMerge: _angular_core.Signal<{
+        width?: string;
+        height?: string;
+        closeOnButton?: boolean;
+        closeOnEsc?: boolean;
+    }>;
+    triggerRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    popoverRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    id: _angular_core.WritableSignal<string>;
+    menuStyle: _angular_core.WritableSignal<any>;
+    openAbort: AbortController | null;
+    openEffect: _angular_core.EffectRef;
+    toggleIsOpen(event: MouseEvent): void;
+    eventClose($event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipPopoverComponent, "sh-popover", never, { "asMultiLayer": { "alias": "asMultiLayer"; "required": false; "isSignal": true; }; "disableOpenByClick": { "alias": "disableOpenByClick"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closed": "closed"; }, never, ["[trigger]", "button", "[shButton]", "*"], true, never>;
+}
+
+type ShipProgressBarMode = 'determinate' | 'indeterminate';
+declare class ShipProgressBarComponent {
+    value: _angular_core.InputSignal<number | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipProgressBarComponent, "sh-progress-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ShipRadioComponent {
+    #private;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipRadioComponent, "sh-radio", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipRangeSliderComponent {
+    #private;
+    unit: _angular_core.InputSignal<string>;
+    value: _angular_core.ModelSignal<number>;
+    inputState: _angular_core.WritableSignal<{
+        min: number;
+        max: number;
+        step: number;
+    }>;
+    valuePercentage: _angular_core.Signal<number>;
+    trackFilledPercentage: _angular_core.Signal<number>;
+    thumbPositionPercentage: _angular_core.Signal<number>;
+    syncModelToInputEffect: _angular_core.EffectRef;
+    get hasInputElement(): boolean;
+    ngAfterViewInit(): void;
+    setNewInputValue(value: string): void;
+    trackEvent(e: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipRangeSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipRangeSliderComponent, "sh-range-slider", never, { "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["label", "input[type=range]"], true, never>;
+}
+
+declare class ShipSelectComponent {
+    #private;
+    value: _angular_core.InputSignal<string | undefined>;
+    label: _angular_core.InputSignal<string | undefined>;
+    asFreeText: _angular_core.InputSignal<boolean>;
+    placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.ModelSignal<boolean>;
+    lazySearch: _angular_core.InputSignal<boolean>;
+    inlineSearch: _angular_core.InputSignal<boolean>;
+    asText: _angular_core.InputSignal<boolean>;
+    isClearable: _angular_core.InputSignal<boolean>;
+    selectMultiple: _angular_core.InputSignal<boolean>;
+    optionTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    selectedOptionTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    placeholderTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    isLoading: _angular_core.ModelSignal<boolean>;
+    options: _angular_core.ModelSignal<unknown[]>;
+    selectedOptions: _angular_core.ModelSignal<unknown[]>;
+    cleared: _angular_core.OutputEmitterRef<void>;
+    inlineTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    optionsWrapRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    inputRefInput: _angular_core.WritableSignal<ElementRef<HTMLInputElement> | null>;
+    inputValue: _angular_core.WritableSignal<string>;
+    prevInputValue: _angular_core.WritableSignal<string | null>;
+    focusedOptionIndex: _angular_core.WritableSignal<number>;
+    _isClearable: _angular_core.Signal<boolean>;
+    selectClasses: _angular_core.Signal<string>;
+    stretch: _angular_core.Signal<boolean>;
+    small: _angular_core.Signal<boolean>;
+    placeholderText: _angular_core.Signal<string | null>;
+    selectedOptionValues: _angular_core.Signal<unknown[]>;
+    filteredOptions: _angular_core.Signal<unknown[]>;
+    inputRefEl: _angular_core.Signal<HTMLInputElement | null | undefined>;
+    openAbortController: AbortController | null;
+    isOpenEffect: _angular_core.EffectRef;
+    _inputValue: string;
+    inputValueEffect: _angular_core.EffectRef;
+    inputRefElEffect: _angular_core.EffectRef;
+    selectedLabels: _angular_core.Signal<string>;
+    inputState: _angular_core.Signal<"open" | "closed" | "selected" | "loading" | "open-searching" | "searching">;
+    hasSearch: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    setInitInput(): void;
+    setSelectedOptionsFromValue(value: string): void;
+    setInputValueFromSelectedOptions(): void;
+    getLabel(option: unknown): unknown;
+    toggleOptionByIndex(optionIndex: number, event?: MouseEvent): void;
+    removeSelectedOptionByIndex($event: MouseEvent, optionRemoveIndex: number): void;
+    isSelected(optionIndex: number): boolean;
+    open(): void;
+    close(): void;
+    clear($event?: MouseEvent): void;
+    updateInputElValue(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipSelectComponent, "sh-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "asFreeText": { "alias": "asFreeText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "lazySearch": { "alias": "lazySearch"; "required": false; "isSignal": true; }; "inlineSearch": { "alias": "inlineSearch"; "required": false; "isSignal": true; }; "asText": { "alias": "asText"; "required": false; "isSignal": true; }; "isClearable": { "alias": "isClearable"; "required": false; "isSignal": true; }; "selectMultiple": { "alias": "selectMultiple"; "required": false; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "selectedOptionTemplate": { "alias": "selectedOptionTemplate"; "required": false; "isSignal": true; }; "placeholderTemplate": { "alias": "placeholderTemplate"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "selectedOptions": { "alias": "selectedOptions"; "required": false; "isSignal": true; }; }, { "readonly": "readonlyChange"; "disabled": "disabledChange"; "isOpen": "isOpenChange"; "isLoading": "isLoadingChange"; "options": "optionsChange"; "selectedOptions": "selectedOptionsChange"; "cleared": "cleared"; }, ["inlineTemplate"], ["label", "input", "textarea"], true, never>;
+}
+
+type ShipSidenavType = 'overlay' | 'simple' | '';
+declare function watchHostClass(className: string): WritableSignal<boolean>;
+declare class ShipSidenavComponent {
+    #private;
+    openWidth: number;
+    openWidthTreshold: number;
+    disableDrag: _angular_core.InputSignal<boolean>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    isOverlay: WritableSignal<boolean>;
+    dragImageElement: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    dragIsEnding: WritableSignal<boolean>;
+    dragIsOnScreen: WritableSignal<boolean>;
+    isDragging: WritableSignal<boolean>;
+    dragPositionX: WritableSignal<number>;
+    dragActualPositionX: _angular_core.Signal<number>;
+    draggingStyle: _angular_core.Signal<string | null>;
+    draggingEffect: _angular_core.EffectRef;
+    drop(e: DragEvent): void;
+    dragEnd(e: DragEvent): void;
+    dragEnter(): void;
+    dragLeave(): void;
+    dragStart(e: DragEvent): void;
+    drag(e: DragEvent): void;
+    touchStart(e: TouchEvent): void;
+    touchMove(e: TouchEvent): void;
+    touchEnd(e: TouchEvent): void;
+    touchCancel(e: TouchEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipSidenavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipSidenavComponent, "sh-sidenav", never, { "disableDrag": { "alias": "disableDrag"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; }, never, ["[sidenav]", "[sidenav-closed-topbar]", "*"], true, never>;
+}
+
+declare class GridSortableDirective {
+    #private;
+    onDragStart(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    onDragEnter(event: DragEvent): void;
+    private updateOrder;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridSortableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridSortableDirective, "[shGridSortable]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ShipSortableComponent<T> {
+    templateOne: _angular_core.Signal<TemplateRef<any>>;
+    templateTwo: _angular_core.Signal<TemplateRef<any>>;
+    placeholderRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    items: _angular_core.ModelSignal<T[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipSortableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipSortableComponent<any>, "sh-sortable", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; }, ["templateOne", "templateTwo"], never, true, never>;
+}
+
+type AfterDropResponse = {
+    fromIndex: number;
+    toIndex: number;
+};
+declare class ShipSortableDirective {
+    #private;
+    dragStartIndex: _angular_core.WritableSignal<number>;
+    dragToIndex: _angular_core.WritableSignal<number>;
+    dragables: _angular_core.WritableSignal<HTMLElement[]>;
+    afterDrop: _angular_core.OutputEmitterRef<AfterDropResponse>;
+    abortController: AbortController | null;
+    isDropping: boolean;
+    draggingEffect: _angular_core.EffectRef;
+    draggablesEffect: _angular_core.EffectRef;
+    getIndexOfElement(element: HTMLElement): number;
+    dragStart(e: DragEvent): void;
+    ngOnInit(): void;
+    dragOver(e: DragEvent): void;
+    drop(): void;
+    dragEnd(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipSortableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ShipSortableDirective, "[shSortable]", never, {}, { "afterDrop": "afterDrop"; }, never, never, true, never>;
+}
+declare function moveIndex<T = any>(array: T[], event: AfterDropResponse): T[];
+
+declare class ShipSpinnerComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipSpinnerComponent, "sh-spinner", never, {}, {}, never, never, true, never>;
+}
+
+declare class ShipStepperComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipStepperComponent, "sh-stepper", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipResizeDirective {
+    #private;
+    resizable: _angular_core.InputSignal<boolean>;
+    minWidth: _angular_core.InputSignal<number>;
+    maxWidth: _angular_core.InputSignal<number | null>;
+    ngOnInit(): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onClick(event: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipResizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ShipResizeDirective, "[shResize]", never, { "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ShipSortDirective {
+    #private;
+    shSort: _angular_core.InputSignal<string | undefined>;
+    sortAsc: _angular_core.Signal<boolean>;
+    sortDesc: _angular_core.Signal<boolean>;
+    toggleSort(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipSortDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ShipSortDirective, "[shSort]", never, { "shSort": { "alias": "shSort"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ShipStickyRowsDirective {
+    #private;
+    shStickyRows: _angular_core.InputSignal<string>;
+    ngAfterContentInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipStickyRowsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ShipStickyRowsDirective, "[shStickyRows]", never, { "shStickyRows": { "alias": "shStickyRows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ShipStickyColumnsDirective {
+    #private;
+    shStickyColumns: _angular_core.InputSignal<string>;
+    ngAfterContentInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipStickyColumnsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ShipStickyColumnsDirective, "[shStickyColumns]", never, { "shStickyColumns": { "alias": "shStickyColumns"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+type ScrollState = -1 | 0 | 1;
+declare class ShipTableComponent {
+    #private;
+    loading: _angular_core.InputSignal<boolean>;
+    data: _angular_core.InputSignal<any>;
+    dataChange: _angular_core.OutputEmitterRef<any>;
+    sortByColumn: _angular_core.ModelSignal<string | null>;
+    tbody: _angular_core.Signal<ElementRef<HTMLTableSectionElement> | undefined>;
+    columns: {
+        signal: _angular_core.Signal<HTMLTableColElement[]>;
+        destroy: () => void;
+    };
+    class: _angular_core.WritableSignal<string>;
+    resizing: _angular_core.WritableSignal<boolean>;
+    sizeTrigger: _angular_core.WritableSignal<boolean>;
+    scrollXState: _angular_core.WritableSignal<ScrollState>;
+    scrollYState: _angular_core.WritableSignal<ScrollState>;
+    canScrollX: _angular_core.WritableSignal<boolean>;
+    canScrollY: _angular_core.WritableSignal<boolean>;
+    columnSizes: _angular_core.Signal<string>;
+    updateColumnSizes(): void;
+    onScroll(): void;
+    onResize(event: Event): void;
+    ngAfterViewInit(): void;
+    e: _angular_core.EffectRef;
+    toggleSort(column: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipTableComponent, "sh-table", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "sortByColumn": { "alias": "sortByColumn"; "required": false; "isSignal": true; }; }, { "dataChange": "dataChange"; "sortByColumn": "sortByColumnChange"; }, never, ["*", "[table-no-rows]"], true, never>;
+}
+
+declare class ShipTabsComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipTabsComponent, "sh-tabs", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipToggleCardComponent {
+    isActive: _angular_core.ModelSignal<boolean>;
+    disallowToggle: _angular_core.InputSignal<boolean>;
+    ngOnInit(): void;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipToggleCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipToggleCardComponent, "sh-toggle-card", never, { "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "disallowToggle": { "alias": "disallowToggle"; "required": false; "isSignal": true; }; }, { "isActive": "isActiveChange"; }, never, ["[title]", "*"], true, never>;
+}
+
+declare class ShipToggleComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipToggleComponent, "sh-toggle", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipTooltipComponent {
+    #private;
+    SUPPORTS_ANCHOR: boolean;
+    disabled: _angular_core.InputSignal<boolean>;
+    above: _angular_core.InputSignal<boolean>;
+    right: _angular_core.InputSignal<boolean>;
+    _above: _angular_core.WritableSignal<boolean>;
+    _right: _angular_core.WritableSignal<boolean>;
+    message: _angular_core.InputSignal<string>;
+    isOpen: _angular_core.ModelSignal<boolean>;
+    closed: _angular_core.OutputEmitterRef<void>;
+    triggerRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    tooltipRef: _angular_core.Signal<ElementRef<HTMLElement>>;
+    id: _angular_core.WritableSignal<string>;
+    menuStyle: _angular_core.WritableSignal<any>;
+    isCalculatingPosition: _angular_core.Signal<boolean>;
+    abortController: AbortController | null;
+    calcPositionEffect: _angular_core.EffectRef;
+    scrollableStyles: string[];
+    eventClose($event: MouseEvent): void;
+    ngOnDestroy(): void;
+    private calculateMenuPosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipTooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipTooltipComponent, "sh-tooltip", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "above": { "alias": "above"; "required": false; "isSignal": true; }; "right": { "alias": "right"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "isOpen": "isOpenChange"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+declare class ShipVirtualScrollComponent {
+    #private;
+    viewportRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    itemElements: _angular_core.Signal<readonly ElementRef<any>[]>;
+    bufferSize: _angular_core.WritableSignal<number>;
+    itemHeights: _angular_core.WritableSignal<number[]>;
+    startIndex: _angular_core.WritableSignal<number>;
+    endIndex: _angular_core.WritableSignal<number>;
+    translateY: _angular_core.WritableSignal<number>;
+    totalHeight: _angular_core.Signal<number>;
+    numberOfRenderedItems: _angular_core.WritableSignal<number>;
+    ngAfterViewInit(): void;
+    onScroll(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipVirtualScrollComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipVirtualScrollComponent, "sh-virtual-scroll", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ShipFileDragDropDirective {
+    filesOver: _angular_core.WritableSignal<boolean>;
+    filesDropped: _angular_core.OutputEmitterRef<FileList>;
+    onDragOver(e: DragEvent): void;
+    onDragLeave(e: DragEvent): void;
+    ondrop(e: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipFileDragDropDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ShipFileDragDropDirective, "[shDragDrop]", never, {}, { "filesDropped": "filesDropped"; }, never, never, true, never>;
+}
+
+declare class ShipPreventWheelDirective {
+    wheel(event: WheelEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipPreventWheelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ShipPreventWheelDirective, "[shPreventWheel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ShipTooltipWrapper {
+    #private;
+    positionAnchorName: _angular_core.InputSignal<string>;
+    anchorEl: _angular_core.InputSignal<ElementRef<HTMLElement>>;
+    isOpen: _angular_core.InputSignal<boolean>;
+    readonly SUPPORTS_ANCHOR: boolean;
+    isBelow: _angular_core.WritableSignal<boolean>;
+    openEffect: _angular_core.EffectRef;
+    constructor();
+    ngOnDestroy(): void;
+    private calculateTooltipPosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipTooltipWrapper, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShipTooltipWrapper, "ship-tooltip-wrapper", never, { "positionAnchorName": { "alias": "positionAnchorName"; "required": true; "isSignal": true; }; "anchorEl": { "alias": "anchorEl"; "required": true; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ShipTooltipDirective implements OnDestroy {
+    #private;
+    shTooltip: _angular_core.InputSignal<string | TemplateRef<any> | null | undefined>;
+    readonly anchorName: string;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    onMouseEnter(): void;
+    ngOnDestroy(): void;
+    private showTooltip;
+    private cleanupTooltip;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShipTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ShipTooltipDirective, "[shTooltip]", never, { "shTooltip": { "alias": "shTooltip"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const SHIP_CONFIG: InjectionToken<ShipConfig>;
+interface ShipConfig {
+    cardType?: 'type-b';
+    dialogType?: 'type-b';
+    tableType?: 'type-b';
+    sidenavType?: 'overlay' | 'simple';
+}
+
+export { GridSortableDirective, SHIP_CONFIG, ShipAlertComponent, ShipAlertContainerComponent, ShipAlertModule, ShipAlertService, ShipButtonComponent, ShipButtonGroupComponent, ShipCardComponent, ShipCheckboxComponent, ShipChipComponent, ShipColorPickerComponent, ShipDatepickerComponent, ShipDatepickerInputComponent, ShipDaterangeInputComponent, ShipDialogComponent, ShipDialogService, ShipDividerComponent, ShipFileDragDropDirective, ShipFileUploadComponent, ShipFormFieldComponent, ShipIconComponent, ShipListComponent, ShipMenuComponent, ShipPopoverComponent, ShipPreventWheelDirective, ShipProgressBarComponent, ShipRadioComponent, ShipRangeSliderComponent, ShipResizeDirective, ShipSelectComponent, ShipSidenavComponent, ShipSortDirective, ShipSortableComponent, ShipSortableDirective, ShipSpinnerComponent, ShipStepperComponent, ShipStickyColumnsDirective, ShipStickyRowsDirective, ShipTableComponent, ShipTabsComponent, ShipToggleCardComponent, ShipToggleComponent, ShipTooltipComponent, ShipTooltipDirective, ShipTooltipWrapper, ShipVirtualScrollComponent, moveIndex, watchHostClass };
+export type { AfterDropResponse, ShipAlertItem, ShipAlertItemInternal, ShipAlertType, ShipDialogOptions, ShipDialogReturn, ShipDialogServiceOptions, ShipPopoverOptions, ShipProgressBarMode, ShipSidenavType };