@haiyue/ui 0.1.2 → 0.2.2

package/dist/index.js

@@ -1,8 +1,17 @@
 import { defineExpandableComponents } from './expandable.js';
 export { defineExpandableComponents, HYExpandable } from './expandable.js';
 import { defineButtonComponents } from './button.js';
+import { defineButtonGroupComponents } from './button-group.js';
 import { defineBorderBeamComponents } from './border-beam.js';
 import { defineTreeComponents } from './tree.js';
+import { defineModalComponents } from './modal.js';
+export { defineModalComponents, HYModal } from './modal.js';
+import { defineQRCodeComponents } from './qr-code.js';
+export { defineQRCodeComponents, HYQRCode } from './qr-code.js';
+import { defineCarouselComponents } from './carousel.js';
+export { defineCarouselComponents, HYCarousel } from './carousel.js';
+import { defineMasonryComponents } from './masonry.js';
+export { defineMasonryComponents, HYMasonry } from './masonry.js';
 import { defineSplitComponents } from './split.js';
 import { defineSelectComponents } from './select.js';
 import { defineTabsComponents } from './tabs.js';
@@ -12,13 +21,35 @@ import { defineTooltipComponents } from './tooltip.js';
 import { defineCheckboxComponents } from './checkbox.js';
 import { defineRadioComponents } from './radio.js';
 import { defineRangeComponents } from './range.js';
+import { defineResizableComponents } from './resizable.js';
 import { defineDialogComponents } from './dialog.js';
 import { defineDrawerComponents } from './drawer.js';
+import { defineDraggableComponents } from './draggable.js';
 import { defineInputComponents } from './input.js';
 import { defineNotificationComponents } from './notification.js';
+import { defineToastComponents } from './toast.js';
 import { defineHistoryControlsComponents } from './history-controls.js';
 import { defineVirtualListComponents } from './virtual-list.js';
+import { defineVirtualMouseComponents } from './virtual-mouse.js';
+import { defineVirtualKeyboardComponents } from './virtual-keyboard.js';
+import { defineTableComponents } from './table.js';
+import { defineBreadcrumbComponents } from './breadcrumb.js';
+import { defineCascaderComponents } from './cascader.js';
+import { defineDatePickerComponents } from './date-picker.js';
+import { defineTimePickerComponents } from './time-picker.js';
+import { defineSkeletonComponents } from './skeleton.js';
+import { defineWatermarkComponents } from './watermark.js';
+import { defineTimelineComponents } from './timeline.js';
+import { defineRateComponents } from './rate.js';
+import { defineDividerComponents } from './divider.js';
+import { defineStepsComponents } from './steps.js';
+import { defineAffixComponents } from './affix.js';
+import { defineTourComponents } from './tour.js';
+import { defineBadgeComponents } from './badge.js';
+import { defineTagComponents } from './tag.js';
+import { defineCollapseComponents } from './collapse.js';
 export { defineButtonComponents, HYButton, } from './button.js';
+export { defineButtonGroupComponents, HYButtonGroup, } from './button-group.js';
 export { defineBorderBeamComponents, HYBorderBeam, } from './border-beam.js';
 export { defineTreeComponents, HYTree, HYTreeNode, } from './tree.js';
 export { defineSplitComponents, HYSplit, } from './split.js';
@@ -30,18 +61,44 @@ export { defineTooltipComponents, HYTooltip, } from './tooltip.js';
 export { defineCheckboxComponents, HYCheckbox, } from './checkbox.js';
 export { defineRadioComponents, HYRadio, } from './radio.js';
 export { defineRangeComponents, HYRange, } from './range.js';
+export { defineResizableComponents, HYResizable, } from './resizable.js';
 export { defineDialogComponents, HYDialog, } from './dialog.js';
 export { defineDrawerComponents, HYDrawer, } from './drawer.js';
+export { defineDraggableComponents, HYDraggable, } from './draggable.js';
 export { defineInputComponents, HYInput, } from './input.js';
 export { defineNotificationComponents, HYNotification, } from './notification.js';
+export { defineToastComponents, HYToast, } from './toast.js';
 export { defineHistoryControlsComponents, HYHistoryControls, } from './history-controls.js';
 export { calculateVirtualListRange, defineVirtualListComponents, HYVirtualList, } from './virtual-list.js';
+export { defineVirtualMouseComponents, HYVirtualMouse, } from './virtual-mouse.js';
+export { defineVirtualKeyboardComponents, HYVirtualKeyboard, HY_VIRTUAL_KEYBOARD_NUMERIC_LAYOUT, HY_VIRTUAL_KEYBOARD_QWERTY_LAYOUT, } from './virtual-keyboard.js';
+export { defineTableComponents, HYTable, } from './table.js';
+export { defineBreadcrumbComponents, HYBreadcrumb, } from './breadcrumb.js';
+export { defineCascaderComponents, HYCascader, } from './cascader.js';
+export { defineDatePickerComponents, HYDatePicker, } from './date-picker.js';
+export { defineTimePickerComponents, HYTimePicker, } from './time-picker.js';
+export { defineSkeletonComponents, HYSkeleton, } from './skeleton.js';
+export { defineWatermarkComponents, HYWatermark, } from './watermark.js';
+export { defineTimelineComponents, HYTimeline, } from './timeline.js';
+export { defineRateComponents, HYRate, } from './rate.js';
+export { defineDividerComponents, HYDivider, } from './divider.js';
+export { defineStepsComponents, HYSteps, } from './steps.js';
+export { defineAffixComponents, HYAffix, } from './affix.js';
+export { defineTourComponents, HYTour, } from './tour.js';
+export { defineBadgeComponents, HYBadge, } from './badge.js';
+export { defineTagComponents, HYTag, } from './tag.js';
+export { defineCollapseComponents, HYCollapse, } from './collapse.js';
 export function defineHaiyueUI() {
     defineExpandableComponents();
     defineBorderBeamComponents();
     defineButtonComponents();
+    defineButtonGroupComponents();
     defineTreeComponents();
     defineSplitComponents();
+    defineMasonryComponents();
+    defineCarouselComponents();
+    defineQRCodeComponents();
+    defineModalComponents();
     defineSelectComponents();
     defineTabsComponents();
     defineContextMenuComponents();
@@ -50,11 +107,32 @@ export function defineHaiyueUI() {
     defineCheckboxComponents();
     defineRadioComponents();
     defineRangeComponents();
+    defineResizableComponents();
     defineDialogComponents();
     defineDrawerComponents();
+    defineDraggableComponents();
     defineInputComponents();
     defineNotificationComponents();
+    defineToastComponents();
     defineHistoryControlsComponents();
     defineVirtualListComponents();
+    defineVirtualMouseComponents();
+    defineVirtualKeyboardComponents();
+    defineTableComponents();
+    defineBreadcrumbComponents();
+    defineCascaderComponents();
+    defineDatePickerComponents();
+    defineTimePickerComponents();
+    defineSkeletonComponents();
+    defineWatermarkComponents();
+    defineTimelineComponents();
+    defineRateComponents();
+    defineDividerComponents();
+    defineStepsComponents();
+    defineAffixComponents();
+    defineTourComponents();
+    defineBadgeComponents();
+    defineTagComponents();
+    defineCollapseComponents();
 }
 //# sourceMappingURL=index.js.map

package/dist/input.d.ts

@@ -1,11 +1,25 @@
-export type HYInputType = 'text' | 'number' | 'color';
+export type HYInputType = 'text' | 'number' | 'color' | 'search' | 'password';
+export type HYInputSearchSource = 'enter' | 'button' | 'api';
 export interface HYInputChangeDetail {
     value: string;
     valueAsNumber: number | null;
     valid: boolean;
 }
+export interface HYInputSearchDetail {
+    value: string;
+    valid: boolean;
+    source: HYInputSearchSource;
+}
 export declare class HYInput extends HTMLElement {
+    private readonly _control;
+    private readonly _prefix;
+    private readonly _prefixSlot;
+    private readonly _prefixText;
     private readonly _input;
+    private readonly _suffix;
+    private readonly _suffixSlot;
+    private readonly _suffixText;
+    private readonly _searchButton;
     static get observedAttributes(): string[];
     constructor();
     connectedCallback(): void;
@@ -16,6 +30,12 @@ export declare class HYInput extends HTMLElement {
     get value(): string;
     set value(value: string);
     get valueAsNumber(): number;
+    get prefix(): string;
+    set prefix(value: string);
+    get suffix(): string;
+    set suffix(value: string);
+    get searchLabel(): string;
+    set searchLabel(value: string);
     get disabled(): boolean;
     set disabled(value: boolean);
     get readOnly(): boolean;
@@ -23,8 +43,17 @@ export declare class HYInput extends HTMLElement {
     get valid(): boolean;
     focus(options?: FocusOptions): void;
     select(): void;
+    search(): boolean;
     private _sync;
+    private _syncAffixes;
+    private _syncAffix;
+    private _syncValidity;
+    private _setOptionalAttribute;
+    private _onSlotChange;
     private _onInput;
     private _onChange;
+    private _onKeydown;
+    private _onSearchClick;
+    private _emitSearch;
 }
 export declare function defineInputComponents(): void;

package/dist/input.js

@@ -1,9 +1,18 @@
 export class HYInput extends HTMLElement {
+    _control = document.createElement('div');
+    _prefix = document.createElement('span');
+    _prefixSlot = document.createElement('slot');
+    _prefixText = document.createElement('span');
     _input = document.createElement('input');
+    _suffix = document.createElement('span');
+    _suffixSlot = document.createElement('slot');
+    _suffixText = document.createElement('span');
+    _searchButton = document.createElement('button');
     static get observedAttributes() {
         return [
             'type', 'value', 'min', 'max', 'step', 'placeholder', 'disabled', 'readonly',
-            'required', 'name', 'autocomplete', 'aria-label', 'title',
+            'required', 'name', 'autocomplete', 'aria-label', 'title', 'prefix', 'suffix',
+            'search-label',
         ];
     }
     constructor() {
@@ -11,74 +20,132 @@ export class HYInput extends HTMLElement {
         const root = this.attachShadow({ mode: 'open' });
         const style = document.createElement('style');
         style.textContent = `
-      :host {
-        display: block;
+      :host { display: block; width: 100%; min-width: 0; }
+      .control {
+        display: flex;
         width: 100%;
         min-width: 0;
-      }
-      input {
-        box-sizing: border-box;
-        width: 100%;
         height: var(--hy-input-height, 28px);
-        min-width: 0;
-        padding: 0 8px;
+        box-sizing: border-box;
+        align-items: stretch;
+        overflow: hidden;
         border: 1px solid var(--hy-border-color, #303746);
-        border-radius: 4px;
-        outline: none;
+        border-radius: var(--hy-input-radius, 4px);
         color: var(--hy-text-color, #d8e2f2);
         background: var(--hy-input-bg-color, var(--hy-surface-color, #121822));
+        transition: border-color 120ms ease, box-shadow 120ms ease;
+      }
+      .control:hover:not(.disabled):not(.readonly) { border-color: var(--hy-hover-border-color, #435268); }
+      .control:focus-within { border-color: var(--hy-focus-border-color, #3d6fa8); box-shadow: 0 0 0 2px var(--hy-focus-ring-color, rgba(61, 111, 168, 0.24)); }
+      .control.invalid { border-color: var(--hy-invalid-border-color, #b64f62); }
+      .control.disabled, .control.readonly { opacity: 0.55; }
+      input {
+        flex: 1 1 auto;
+        width: 0;
+        min-width: 0;
+        box-sizing: border-box;
+        padding: 0 var(--hy-input-padding-inline, 8px);
+        border: 0;
+        outline: none;
+        color: inherit;
+        background: transparent;
         font: var(--hy-input-font, 12px system-ui, sans-serif);
         color-scheme: inherit;
       }
-      input:hover:not(:disabled):not(:read-only) {
-        border-color: var(--hy-hover-border-color, #435268);
-      }
-      input:focus {
-        border-color: var(--hy-focus-border-color, #3d6fa8);
-        box-shadow: 0 0 0 2px var(--hy-focus-ring-color, rgba(61, 111, 168, 0.24));
-      }
-      input:invalid {
-        border-color: var(--hy-invalid-border-color, #b64f62);
-      }
-      input:disabled,
-      input:read-only {
-        opacity: 0.55;
-        cursor: default;
-      }
-      input[type="color"] {
-        padding: 3px;
-        cursor: pointer;
-      }
+      input:disabled, input:read-only { cursor: default; }
+      input[type="color"] { min-width: 42px; padding: 3px; cursor: pointer; }
       input[type="color"]::-webkit-color-swatch-wrapper { padding: 0; }
-      input[type="color"]::-webkit-color-swatch {
+      input[type="color"]::-webkit-color-swatch { border: 0; border-radius: 2px; }
+      input[type="search"]::-webkit-search-cancel-button { cursor: pointer; }
+      .affix {
+        display: inline-flex;
+        flex: 0 0 auto;
+        align-items: center;
+        max-width: 42%;
+        padding-inline: var(--hy-input-affix-padding, 8px);
+        overflow: hidden;
+        color: var(--hy-input-affix-color, var(--hy-muted-text-color, #8290a3));
+        font: var(--hy-input-affix-font, 12px system-ui, sans-serif);
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+      .prefix { padding-right: 0; }
+      .suffix { padding-left: 0; }
+      .affix[hidden], .search-button[hidden] { display: none; }
+      .search-button {
+        display: grid;
+        flex: 0 0 var(--hy-input-search-button-width, 32px);
+        width: var(--hy-input-search-button-width, 32px);
+        padding: 0;
+        place-items: center;
         border: 0;
-        border-radius: 2px;
+        border-left: 1px solid var(--hy-border-color, #303746);
+        color: var(--hy-input-search-color, var(--hy-accent-color, #79a8ff));
+        background: var(--hy-input-search-bg, color-mix(in srgb, var(--hy-accent-color, #79a8ff) 11%, transparent));
+        cursor: pointer;
+        font: 16px/1 system-ui, sans-serif;
       }
+      .search-button:hover:not(:disabled) { background: var(--hy-input-search-hover-bg, color-mix(in srgb, var(--hy-accent-color, #79a8ff) 20%, transparent)); }
+      .search-button:focus-visible { outline: 2px solid var(--hy-focus-border-color, #3d6fa8); outline-offset: -3px; }
+      .search-button:disabled { cursor: default; }
+      @media (prefers-reduced-motion: reduce) { .control { transition: none; } }
     `;
-        root.append(style, this._input);
+        this._control.className = 'control';
+        this._control.part.add('control');
+        this._prefix.className = 'affix prefix';
+        this._prefix.part.add('prefix');
+        this._prefixSlot.name = 'prefix';
+        this._prefixText.className = 'affix-text';
+        this._prefix.append(this._prefixSlot, this._prefixText);
+        this._input.part.add('input');
+        this._suffix.className = 'affix suffix';
+        this._suffix.part.add('suffix');
+        this._suffixSlot.name = 'suffix';
+        this._suffixText.className = 'affix-text';
+        this._suffix.append(this._suffixSlot, this._suffixText);
+        this._searchButton.className = 'search-button';
+        this._searchButton.type = 'button';
+        this._searchButton.part.add('search-button');
+        this._searchButton.textContent = '⌕';
+        this._control.append(this._prefix, this._input, this._suffix, this._searchButton);
+        root.append(style, this._control);
     }
     connectedCallback() {
         this._input.addEventListener('input', this._onInput);
         this._input.addEventListener('change', this._onChange);
+        this._input.addEventListener('keydown', this._onKeydown);
+        this._searchButton.addEventListener('click', this._onSearchClick);
+        this._prefixSlot.addEventListener('slotchange', this._onSlotChange);
+        this._suffixSlot.addEventListener('slotchange', this._onSlotChange);
         this._sync();
     }
     disconnectedCallback() {
         this._input.removeEventListener('input', this._onInput);
         this._input.removeEventListener('change', this._onChange);
+        this._input.removeEventListener('keydown', this._onKeydown);
+        this._searchButton.removeEventListener('click', this._onSearchClick);
+        this._prefixSlot.removeEventListener('slotchange', this._onSlotChange);
+        this._suffixSlot.removeEventListener('slotchange', this._onSlotChange);
     }
-    attributeChangedCallback() {
-        this._sync();
-    }
+    attributeChangedCallback() { this._sync(); }
     get type() { return normalizedType(this.getAttribute('type')); }
     set type(value) { this.setAttribute('type', normalizedType(value)); }
     get value() { return this.getAttribute('value') ?? ''; }
     set value(value) {
-        this.setAttribute('value', String(value));
-        this._input.value = String(value);
-    }
-    get valueAsNumber() {
-        return this._input.valueAsNumber;
+        const text = String(value);
+        if (this.getAttribute('value') !== text)
+            this.setAttribute('value', text);
+        if (this._input.value !== text)
+            this._input.value = text;
+        this._syncValidity();
     }
+    get valueAsNumber() { return this._input.valueAsNumber; }
+    get prefix() { return this.getAttribute('prefix') ?? ''; }
+    set prefix(value) { this._setOptionalAttribute('prefix', value); }
+    get suffix() { return this.getAttribute('suffix') ?? ''; }
+    set suffix(value) { this._setOptionalAttribute('suffix', value); }
+    get searchLabel() { return this.getAttribute('search-label')?.trim() || 'Search'; }
+    set searchLabel(value) { this._setOptionalAttribute('search-label', value); }
     get disabled() { return this.hasAttribute('disabled'); }
     set disabled(value) { this.toggleAttribute('disabled', value); }
     get readOnly() { return this.hasAttribute('readonly'); }
@@ -86,46 +153,91 @@ export class HYInput extends HTMLElement {
     get valid() { return this._input.validity.valid; }
     focus(options) { this._input.focus(options); }
     select() { this._input.select(); }
+    search() { return this._emitSearch('api'); }
     _sync() {
         const type = this.type;
         if (this._input.type !== type)
             this._input.type = type;
         const value = this.value;
         if (this._input.value !== value)
-            this._input.value = type === 'color' && !/^#[0-9a-f]{6}$/iu.test(value)
-                ? '#000000'
-                : value;
+            this._input.value = type === 'color' && !/^#[0-9a-f]{6}$/iu.test(value) ? '#000000' : value;
         for (const name of ['min', 'max', 'step', 'placeholder', 'name', 'autocomplete', 'aria-label', 'title']) {
             const attribute = this.getAttribute(name);
-            if (attribute === null)
-                this._input.removeAttribute(name);
-            else
+            if (attribute === null) {
+                if (this._input.hasAttribute(name))
+                    this._input.removeAttribute(name);
+            }
+            else if (this._input.getAttribute(name) !== attribute)
                 this._input.setAttribute(name, attribute);
         }
-        this._input.disabled = this.disabled;
-        this._input.readOnly = this.readOnly;
-        this._input.required = this.hasAttribute('required');
+        // Reassigning even an unchanged placeholder or state can split Chromium's undo group.
+        if (this._input.disabled !== this.disabled)
+            this._input.disabled = this.disabled;
+        if (this._input.readOnly !== this.readOnly)
+            this._input.readOnly = this.readOnly;
+        if (this._input.required !== this.hasAttribute('required'))
+            this._input.required = this.hasAttribute('required');
+        this._searchButton.hidden = type !== 'search';
+        this._searchButton.disabled = this.disabled;
+        this._searchButton.setAttribute('aria-label', this.searchLabel);
+        this._control.classList.toggle('disabled', this.disabled);
+        this._control.classList.toggle('readonly', this.readOnly);
+        this._syncAffixes();
+        this._syncValidity();
     }
+    _syncAffixes() {
+        this._syncAffix(this._prefix, this._prefixSlot, this._prefixText, this.prefix);
+        this._syncAffix(this._suffix, this._suffixSlot, this._suffixText, this.suffix);
+    }
+    _syncAffix(container, slot, fallback, text) {
+        const hasAssignedContent = slot.assignedNodes({ flatten: true }).some(node => node.nodeType === Node.ELEMENT_NODE || Boolean(node.textContent?.trim()));
+        fallback.textContent = hasAssignedContent ? '' : text;
+        fallback.hidden = hasAssignedContent || !text;
+        container.hidden = !hasAssignedContent && !text;
+    }
+    _syncValidity() { this._control.classList.toggle('invalid', !this.valid); }
+    _setOptionalAttribute(name, value) {
+        const normalized = String(value ?? '').trim();
+        if (normalized)
+            this.setAttribute(name, normalized);
+        else
+            this.removeAttribute(name);
+    }
+    _onSlotChange = () => { this._syncAffixes(); };
     _onInput = () => {
         this.setAttribute('value', this._input.value);
+        this._syncValidity();
     };
     _onChange = () => {
         this.setAttribute('value', this._input.value);
-        const number = this.type === 'number' && Number.isFinite(this._input.valueAsNumber)
-            ? this._input.valueAsNumber
-            : null;
+        const number = this.type === 'number' && Number.isFinite(this._input.valueAsNumber) ? this._input.valueAsNumber : null;
         this.dispatchEvent(new CustomEvent('value-change', {
             detail: { value: this._input.value, valueAsNumber: number, valid: this.valid },
             bubbles: true,
             composed: true,
         }));
     };
+    _onKeydown = (event) => {
+        if (event.key === 'Enter' && this.type === 'search' && !event.isComposing)
+            this._emitSearch('enter');
+    };
+    _onSearchClick = () => { this._emitSearch('button'); };
+    _emitSearch(source) {
+        if (this.disabled || this.type !== 'search')
+            return false;
+        return this.dispatchEvent(new CustomEvent('search', {
+            detail: { value: this._input.value, valid: this.valid, source },
+            bubbles: true,
+            composed: true,
+            cancelable: true,
+        }));
+    }
 }
 export function defineInputComponents() {
     if (!customElements.get('hy-input'))
         customElements.define('hy-input', HYInput);
 }
 function normalizedType(value) {
-    return value === 'number' || value === 'color' ? value : 'text';
+    return value === 'number' || value === 'color' || value === 'search' || value === 'password' ? value : 'text';
 }
 //# sourceMappingURL=input.js.map

package/dist/internal/qrcodegen.d.ts

@@ -0,0 +1,94 @@
+declare namespace qrcodegen {
+    type bit = number;
+    type byte = number;
+    type int = number;
+    export class QrCode {
+        readonly version: int;
+        readonly errorCorrectionLevel: QrCode.Ecc;
+        static encodeText(text: string, ecl: QrCode.Ecc): QrCode;
+        static encodeBinary(data: Readonly<Array<byte>>, ecl: QrCode.Ecc): QrCode;
+        static encodeSegments(segs: Readonly<Array<QrSegment>>, ecl: QrCode.Ecc, minVersion?: int, maxVersion?: int, mask?: int, boostEcl?: boolean): QrCode;
+        readonly size: int;
+        readonly mask: int;
+        private readonly modules;
+        private readonly isFunction;
+        constructor(version: int, errorCorrectionLevel: QrCode.Ecc, dataCodewords: Readonly<Array<byte>>, msk: int);
+        getModule(x: int, y: int): boolean;
+        private drawFunctionPatterns;
+        private drawFormatBits;
+        private drawVersion;
+        private drawFinderPattern;
+        private drawAlignmentPattern;
+        private setFunctionModule;
+        private addEccAndInterleave;
+        private drawCodewords;
+        private applyMask;
+        private getPenaltyScore;
+        private getAlignmentPatternPositions;
+        private static getNumRawDataModules;
+        private static getNumDataCodewords;
+        private static reedSolomonComputeDivisor;
+        private static reedSolomonComputeRemainder;
+        private static reedSolomonMultiply;
+        private finderPenaltyCountPatterns;
+        private finderPenaltyTerminateAndCount;
+        private finderPenaltyAddHistory;
+        static readonly MIN_VERSION: int;
+        static readonly MAX_VERSION: int;
+        private static readonly PENALTY_N1;
+        private static readonly PENALTY_N2;
+        private static readonly PENALTY_N3;
+        private static readonly PENALTY_N4;
+        private static readonly ECC_CODEWORDS_PER_BLOCK;
+        private static readonly NUM_ERROR_CORRECTION_BLOCKS;
+    }
+    export class QrSegment {
+        readonly mode: QrSegment.Mode;
+        readonly numChars: int;
+        private readonly bitData;
+        static makeBytes(data: Readonly<Array<byte>>): QrSegment;
+        static makeNumeric(digits: string): QrSegment;
+        static makeAlphanumeric(text: string): QrSegment;
+        static makeSegments(text: string): Array<QrSegment>;
+        static makeEci(assignVal: int): QrSegment;
+        static isNumeric(text: string): boolean;
+        static isAlphanumeric(text: string): boolean;
+        constructor(mode: QrSegment.Mode, numChars: int, bitData: Array<bit>);
+        getData(): Array<bit>;
+        static getTotalBits(segs: Readonly<Array<QrSegment>>, version: int): number;
+        private static toUtf8ByteArray;
+        private static readonly NUMERIC_REGEX;
+        private static readonly ALPHANUMERIC_REGEX;
+        private static readonly ALPHANUMERIC_CHARSET;
+    }
+    export {};
+}
+declare namespace qrcodegen.QrCode {
+    type int = number;
+    export class Ecc {
+        readonly ordinal: int;
+        readonly formatBits: int;
+        static readonly LOW: Ecc;
+        static readonly MEDIUM: Ecc;
+        static readonly QUARTILE: Ecc;
+        static readonly HIGH: Ecc;
+        private constructor();
+    }
+    export {};
+}
+declare namespace qrcodegen.QrSegment {
+    type int = number;
+    export class Mode {
+        readonly modeBits: int;
+        private readonly numBitsCharCount;
+        static readonly NUMERIC: Mode;
+        static readonly ALPHANUMERIC: Mode;
+        static readonly BYTE: Mode;
+        static readonly KANJI: Mode;
+        static readonly ECI: Mode;
+        private constructor();
+        numCharCountBits(ver: int): int;
+    }
+    export {};
+}
+export { qrcodegen };