DefinitelyTyped/types/semantic-ui-dimmer/global.d.ts

interface JQuery {
    dimmer: SemanticUI.Dimmer;
}

declare namespace SemanticUI {
    interface Dimmer {
        settings: DimmerSettings;

        /**
         * Detaches a given element from DOM and reattaches element inside dimmer
         */
        (behavior: 'add content', element: string | JQuery): JQuery;
        /**
         * Shows dimmer
         */
        (behavior: 'show'): JQuery;
        /**
         * Hides dimmer
         */
        (behavior: 'hide'): JQuery;
        /**
         * Toggles current dimmer visibility
         */
        (behavior: 'toggle'): JQuery;
        /**
         * Changes dimmer opacity
         */
        (behavior: 'set opacity', opacity: number): JQuery;
        /**
         * Creates a new dimmer in dimmable context
         */
        (behavior: 'create'): JQuery;
        /**
         * Returns current duration for show or hide event depending on current visibility
         */
        (behavior: 'get duration'): number;
        /**
         * Returns DOM element for dimmer
         */
        (behavior: 'get dimmer'): JQuery;
        /**
         * Returns whether current dimmable has a dimmer
         */
        (behavior: 'has dimmer'): boolean;
        /**
         * Whether section's dimmer is active
         */
        (behavior: 'is active'): boolean;
        /**
         * Whether dimmer is animating
         */
        (behavior: 'is animating'): boolean;
        /**
         * Whether current element is a dimmer
         */
        (behavior: 'is dimmer'): boolean;
        /**
         * Whether current element is a dimmable section
         */
        (behavior: 'is dimmable'): boolean;
        /**
         * Whether dimmer is disabled
         */
        (behavior: 'is disabled'): boolean;
        /**
         * Whether dimmer is not disabled
         */
        (behavior: 'is enabled'): boolean;
        /**
         * Whether dimmable section is body
         */
        (behavior: 'is page'): boolean;
        /**
         * Whether dimmer is a page dimmer
         */
        (behavior: 'is page dimmer'): boolean;
        /**
         * Sets page dimmer to active
         */
        (behavior: 'set active'): JQuery;
        /**
         * Sets an element as a dimmable section
         */
        (behavior: 'set dimmable'): JQuery;
        /**
         * Sets a dimmable section as dimmed
         */
        (behavior: 'set dimmed'): JQuery;
        /**
         * Sets current dimmer as a page dimmer
         */
        (behavior: 'set page dimmer'): JQuery;
        /**
         * Sets a dimmer as disabled
         */
        (behavior: 'set disabled'): JQuery;
        (behavior: 'destroy'): JQuery;
        <K extends keyof DimmerSettings>(behavior: 'setting', name: K, value?: undefined): DimmerSettings._Impl[K];
        <K extends keyof DimmerSettings>(behavior: 'setting', name: K, value: DimmerSettings._Impl[K]): JQuery;
        (behavior: 'setting', value: DimmerSettings): JQuery;
        (settings?: DimmerSettings): JQuery;
    }

    /**
     * @see {@link http://semantic-ui.com/modules/dimmer.html#/settings}
     */
    type DimmerSettings = DimmerSettings.Param;

    namespace DimmerSettings {
        type Param = (Pick<_Impl, 'opacity'> |
            Pick<_Impl, 'variation'> |
            Pick<_Impl, 'dimmerName'> |
            Pick<_Impl, 'closable'> |
            Pick<_Impl, 'on'> |
            Pick<_Impl, 'useCSS'> |
            Pick<_Impl, 'duration'> |
            Pick<_Impl, 'transition'> |
            Pick<_Impl, 'onShow'> |
            Pick<_Impl, 'onHide'> |
            Pick<_Impl, 'onChange'> |
            Pick<_Impl, 'selector'> |
            Pick<_Impl, 'template'> |
            Pick<_Impl, 'className'> |
            Pick<_Impl, 'error'> |
            Pick<_Impl, 'namespace'> |
            Pick<_Impl, 'name'> |
            Pick<_Impl, 'silent'> |
            Pick<_Impl, 'debug'> |
            Pick<_Impl, 'performance'> |
            Pick<_Impl, 'verbose'>) &
            Partial<Pick<_Impl, keyof _Impl>>;

        interface _Impl {
            // region Behavior

            /**
             * Dimmers opacity from 0-1. Defaults to auto which uses the CSS specified opacity.
             *
             * @default 'auto'
             */
            opacity: 'auto' | number;
            /**
             * Specify a variation to add when generating dimmer, like inverted
             *
             * @default false
             */
            variation: false | string;
            /**
             * If initializing a dimmer on a dimmable context, you can use dimmerName to distinguish between multiple dimmers in that context.
             *
             * @default false
             */
            dimmerName: false | string;
            /**
             * Whether clicking on the dimmer should hide the dimmer (Defaults to auto, closable only when settings.on is not hover
             *
             * @default 'auto'
             */
            closable: 'auto' | boolean;
            /**
             * Can be set to hover or click to show/hide dimmer on dimmable event
             *
             * @default false
             */
            on: false | 'hover' | 'click';
            /**
             * Whether to dim dimmers using CSS transitions.
             *
             * @default true
             */
            useCSS: boolean;
            /**
             * Animation duration of dimming. If an integer is used, that value will apply to both show and hide animations.
             */
            duration: number | Dimmer.DurationSettings;
            /**
             * Named transition to use when animating menu in and out. Fade and slide down are available without including ui transitions
             *
             * @default 'fade'
             * @see {@link http://semantic-ui.com/modules/transition.html}
             */
            transition: string;

            // endregion

            // region Callbacks

            /**
             * Callback on element show
             */
            onShow(this: JQuery): void;
            /**
             * Callback on element hide
             */
            onHide(this: JQuery): void;
            /**
             * Callback on element show or hide
             */
            onChange(this: JQuery): void;

            // endregion

            // region DOM Settings

            /**
             * Object containing selectors used by module.
             */
            selector: Dimmer.SelectorSettings;
            /**
             * Templates used to generate dimmer content
             */
            template: Dimmer.TemplateSettings;
            /**
             * Class names used to attach style to state
             */
            className: Dimmer.ClassNameSettings;

            // endregion

            // region Debug Settings

            /**
             * Error messages displayed to console
             */
            error: Dimmer.ErrorSettings;

            // endregion

            // region Component Settings

            // region DOM Settings

            /**
             * Event namespace. Makes sure module teardown does not effect other events attached to an element.
             */
            namespace: string;

            // endregion

            // region Debug Settings

            /**
             * Name used in log statements
             */
            name: string;
            /**
             * Silences all console output including error messages, regardless of other debug settings.
             */
            silent: boolean;
            /**
             * Debug output to console
             */
            debug: boolean;
            /**
             * Show console.table output with performance metrics
             */
            performance: boolean;
            /**
             * Debug output includes all internal behaviors
             */
            verbose: boolean;

            // endregion

            // endregion
        }
    }

    namespace Dimmer {
        type DurationSettings = DurationSettings.Param;

        namespace DurationSettings {
            type Param = (Pick<_Impl, 'show'> |
                Pick<_Impl, 'hide'>) &
                Partial<Pick<_Impl, keyof _Impl>>;

            interface _Impl {
                /**
                 * @default 500
                 */
                show: number;
                /**
                 * @default 500
                 */
                hide: number;
            }
        }

        type SelectorSettings = SelectorSettings.Param;

        namespace SelectorSettings {
            type Param = (Pick<_Impl, 'dimmable'> |
                Pick<_Impl, 'dimmer'> |
                Pick<_Impl, 'content'>) &
                Partial<Pick<_Impl, keyof _Impl>>;

            interface _Impl {
                /**
                 * @default '.dimmable'
                 */
                dimmable: string;
                /**
                 * @default '.ui.dimmer'
                 */
                dimmer: string;
                /**
                 * @default '.ui.dimmer > .content, .ui.dimmer > .content > .center'
                 */
                content: string;
            }
        }

        type TemplateSettings = TemplateSettings.Param;

        namespace TemplateSettings {
            type Param = (Pick<_Impl, 'dimmer'>) &
                Partial<Pick<_Impl, keyof _Impl>>;

            interface _Impl {
                dimmer(): JQuery;
            }
        }

        type ClassNameSettings = ClassNameSettings.Param;

        namespace ClassNameSettings {
            type Param = (Pick<_Impl, 'active'> |
                Pick<_Impl, 'dimmable'> |
                Pick<_Impl, 'dimmed'> |
                Pick<_Impl, 'disabled'> |
                Pick<_Impl, 'pageDimmer'> |
                Pick<_Impl, 'hide'> |
                Pick<_Impl, 'show'> |
                Pick<_Impl, 'transition'>) &
                Partial<Pick<_Impl, keyof _Impl>>;

            interface _Impl {
                /**
                 * @default 'active'
                 */
                active: string;
                /**
                 * @default 'dimmable'
                 */
                dimmable: string;
                /**
                 * @default 'dimmed'
                 */
                dimmed: string;
                /**
                 * @default 'disabled'
                 */
                disabled: string;
                /**
                 * @default 'page'
                 */
                pageDimmer: string;
                /**
                 * @default 'hide'
                 */
                hide: string;
                /**
                 * @default 'show'
                 */
                show: string;
                /**
                 * @default 'transition'
                 */
                transition: string;
            }
        }

        type ErrorSettings = ErrorSettings.Param;

        namespace ErrorSettings {
            type Param = (Pick<_Impl, 'method'>) &
                Partial<Pick<_Impl, keyof _Impl>>;

            interface _Impl {
                /**
                 * @default 'The method you called is not defined.'
                 */
                method: string;
            }
        }
    }
}