@koobiq/components 20.4.2 → 21.0.1

package/types/koobiq-components-timepicker.d.ts

@@ -0,0 +1,223 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnChanges, DoCheck, AfterContentInit, SimpleChanges, Provider } from '@angular/core';
+import * as i3 from '@angular/forms';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as i1 from '@koobiq/components/core';
+import { KbqTimepickerLocaleConfiguration, ErrorStateMatcher, KbqDeepPartial } from '@koobiq/components/core';
+import * as i5 from '@koobiq/components/form-field';
+import { KbqFormFieldControl } from '@koobiq/components/form-field';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+import * as i1$1 from '@angular/cdk/a11y';
+import * as i2 from '@angular/cdk/platform';
+
+declare enum TimeParts {
+    hours = 0,
+    minutes = 1,
+    seconds = 2
+}
+declare enum TimeFormats {
+    HHmmss = "HH:mm:ss",
+    HHmm = "HH:mm"
+}
+declare const TIMEFORMAT_PLACEHOLDERS: {
+    [timeFormat: string]: string;
+};
+/** Object that maps each time format to a related locale key */
+declare const TimeFormatToLocaleKeys: Record<TimeFormats, 'full' | 'short'>;
+declare const DEFAULT_TIME_FORMAT: TimeFormats;
+declare const HOURS_MINUTES_SECONDS_REGEXP: RegExp;
+declare const HOURS_MINUTES_REGEXP: RegExp;
+declare const HOURS_ONLY_REGEXP: RegExp;
+declare const AM_PM_FORMAT_REGEXP: RegExp;
+declare const SECONDS_PER_MINUTE: number;
+declare const MINUTES_PER_HOUR: number;
+declare const HOURS_PER_DAY: number;
+
+/** @docs-private */
+declare const KBQ_TIMEPICKER_VALUE_ACCESSOR: any;
+/** @docs-private */
+declare const KBQ_TIMEPICKER_VALIDATORS: any;
+/**
+ * Default configuration of the timepicker.
+ *
+ * @docs-private
+ */
+declare const KBQ_TIMEPICKER_DEFAULT_LOCALE_CONFIGURATION: KbqTimepickerLocaleConfiguration;
+/**
+ * Injection token for providing the default configuration of the timepicker.
+ *
+ * @docs-private
+ */
+declare const KBQ_TIMEPICKER_LOCALE_CONFIGURATION: InjectionToken<KbqTimepickerLocaleConfiguration>;
+/**
+ * Utility provider for `KBQ_TIMEPICKER_LOCALE_CONFIGURATION`. Only the strings you pass are overridden; the rest
+ * keep following the active locale.
+ */
+declare const kbqTimepickerLocaleConfigurationProvider: (configuration: KbqDeepPartial<KbqTimepickerLocaleConfiguration>) => Provider;
+declare class KbqTimepicker<D> implements KbqFormFieldControl<D>, ControlValueAccessor, Validator, OnChanges, DoCheck, AfterContentInit {
+    private readonly uid;
+    private elementRef;
+    private readonly renderer;
+    private dateAdapter;
+    private readonly timezoneService;
+    private readonly localeConfiguration;
+    private readonly errorStateTracker;
+    /** @docs-private */
+    readonly errorState: _angular_core.Signal<boolean>;
+    private readonly focusedValue;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly focused: _angular_core.Signal<boolean>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    controlType: string;
+    /** Object used to control when error messages are shown. */
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    /** @docs-private */
+    readonly placeholderInput: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Implemented as part of KbqFormFieldControl. Defaults to the localized pattern of `format`.
+     *
+     * @docs-private
+     */
+    readonly placeholder: _angular_core.Signal<string>;
+    /** @docs-private */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** Whether the timepicker is disabled. Also set by the bound form control. */
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    /** @docs-private */
+    readonly idInput: _angular_core.InputSignal<string | undefined>;
+    /** Unique id of the element, generated when not provided. */
+    readonly id: _angular_core.Signal<string>;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, string | boolean | null | undefined>;
+    /** Time format the input parses and renders. An unsupported value falls back to the default. */
+    readonly format: _angular_core.InputSignalWithTransform<TimeFormats, TimeFormats | null | undefined>;
+    /** Earliest time the control accepts. Anything the date adapter cannot read is treated as unset. */
+    readonly min: _angular_core.InputSignal<D | null>;
+    /** Latest time the control accepts. Anything the date adapter cannot read is treated as unset. */
+    readonly max: _angular_core.InputSignal<D | null>;
+    /** `min` as the date adapter reads it, or null when it cannot. */
+    private readonly minDate;
+    /** `max` as the date adapter reads it, or null when it cannot. */
+    private readonly maxDate;
+    /** @docs-private */
+    readonly valueInput: _angular_core.InputSignal<D | null | undefined>;
+    private readonly valueState;
+    /** The time the control holds: set with `[value]`, by the form control and by typing. */
+    readonly value: _angular_core.Signal<D | null>;
+    /** Tooltip shown for a moment whenever a keystroke is rejected. */
+    readonly kbqValidationTooltip: _angular_core.InputSignal<KbqTooltipTrigger | undefined>;
+    readonly incorrectInput: _angular_core.OutputEmitterRef<void>;
+    get hasSelection(): boolean;
+    get isFullFormat(): boolean;
+    get isShortFormat(): boolean;
+    get viewValue(): string;
+    get ngControl(): any;
+    private readonly emptyValue;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    readonly empty: _angular_core.Signal<boolean>;
+    get selectionStart(): number | null;
+    set selectionStart(value: number | null);
+    get selectionEnd(): number | null;
+    set selectionEnd(value: number | null);
+    /** Localized placeholder */
+    get timeFormatPlaceholder(): string;
+    private readonly validator;
+    private lastValueValid;
+    private control?;
+    private separator;
+    /** Start of the part a caret key selects on a timer, until the selection lands there. */
+    private pendingCaret;
+    private onChange;
+    private onTouched;
+    constructor();
+    ngDoCheck(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getSize(): number;
+    focus(): void;
+    focusChanged(isFocused: boolean): void;
+    onBlur(): void;
+    onPaste($event: any): void;
+    onInput: () => void;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     *
+     * @docs-private
+     */
+    onContainerClick(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    writeValue(value: D | null): void;
+    registerOnChange(fn: (value: D) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private formatUserPaste;
+    private formatUserInput;
+    private replaceSymbols;
+    private replaceNumbers;
+    /** Clamps a time part to the allowed maximum and trims it to two digits */
+    private normalizeTimePart;
+    /** Checks whether the input is invalid based on the native validation. */
+    private isBadInput;
+    /** Whether the input renders no text, read from the element rather than from the last change detection. */
+    private isEmpty;
+    private spaceKeyHandler;
+    private getNewValue;
+    private verticalArrowKeyHandler;
+    private fixEmptyDigit;
+    private horizontalArrowKeyHandler;
+    private createSelectionOfTimeComponentInInput;
+    private incrementTime;
+    private decrementTime;
+    /**
+     * Get params for arrow-keys (up/down) time value edit.
+     *
+     * @param cursorPosition Current cursor position in timeString
+     */
+    private getTimeEditMetrics;
+    /**
+     * Create time string for displaying inside input element of UI
+     */
+    private getTimeStringFromDate;
+    private getDateFromTimeString;
+    private parseValidator;
+    private minValidator;
+    private maxValidator;
+    private getValidDateOrNull;
+    private setViewValue;
+    private setSelection;
+    private updateView;
+    /** @docs-private */
+    updateErrorState(): void;
+    /** Takes a value from any source, re-rendering the element with it. */
+    private setValue;
+    private setControl;
+    private validatorOnChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTimepicker<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqTimepicker<any>, "input[kbqTimepicker]", ["kbqTimepicker"], { "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "placeholderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "kbqValidationTooltip": { "alias": "kbqValidationTooltip"; "required": false; "isSignal": true; }; }, { "incorrectInput": "incorrectInput"; }, never, never, true, [{ directive: typeof i1.KbqLocaleOverridesDirective; inputs: { "kbqLocaleOverrides": "localeOverrides"; }; outputs: {}; }]>;
+}
+
+declare class KbqTimepickerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqTimepickerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqTimepickerModule, never, [typeof i1$1.A11yModule, typeof i2.PlatformModule, typeof i3.FormsModule, typeof KbqTimepicker], [typeof KbqTimepicker, typeof i5.KbqFormFieldModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqTimepickerModule>;
+}
+
+export { AM_PM_FORMAT_REGEXP, DEFAULT_TIME_FORMAT, HOURS_MINUTES_REGEXP, HOURS_MINUTES_SECONDS_REGEXP, HOURS_ONLY_REGEXP, HOURS_PER_DAY, KBQ_TIMEPICKER_DEFAULT_LOCALE_CONFIGURATION, KBQ_TIMEPICKER_LOCALE_CONFIGURATION, KBQ_TIMEPICKER_VALIDATORS, KBQ_TIMEPICKER_VALUE_ACCESSOR, KbqTimepicker, KbqTimepickerModule, MINUTES_PER_HOUR, SECONDS_PER_MINUTE, TIMEFORMAT_PLACEHOLDERS, TimeFormatToLocaleKeys, TimeFormats, TimeParts, kbqTimepickerLocaleConfigurationProvider };

package/types/koobiq-components-timezone.d.ts

@@ -0,0 +1,266 @@
+import * as i0 from '@angular/core';
+import { PipeTransform, ElementRef, AfterViewInit, OnDestroy, InjectionToken, Provider } from '@angular/core';
+import * as i6 from '@koobiq/components/core';
+import { KbqOption, KbqTimezoneLocaleConfiguration, KbqDeepPartial } from '@koobiq/components/core';
+import { KbqTooltipTrigger } from '@koobiq/components/tooltip';
+import { KbqSelect } from '@koobiq/components/select';
+import * as i7 from '@koobiq/components/form-field';
+
+/** Narrows a `', '`-joined city list to the entries matching the search pattern(s). */
+declare class CitiesByFilterPipe implements PipeTransform {
+    transform(value: string, searchPattern?: string | readonly string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CitiesByFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CitiesByFilterPipe, "citiesByFilter", true>;
+}
+
+/** One row of the timezone list: a zone, the city it is named after and the country it belongs to. */
+interface KbqTimezoneZone {
+    /** IANA time zone name, e.g. `Europe/Berlin`. Used as the form value and to resolve the offset. */
+    id: string;
+    /**
+     * Fixed offset from UTC, written as `HH:MM:SS` with an optional leading `-` (`03:00:00`, `-02:00:00`).
+     *
+     * Optional, and omitting it is the safer choice: the offset is then resolved from {@link id} at render
+     * time, so a zone that observes DST is labelled correctly on both sides of the change. A string
+     * supplied here is rendered verbatim and never recomputed — the consumer owns keeping it current.
+     */
+    offset?: string;
+    /** Name of the city the zone is displayed under. */
+    city: string;
+    /** ISO 3166-1 alpha-2 code of the country the zone belongs to. Matched case-insensitively. */
+    countryCode: string;
+    /** Display name of the country the zone belongs to. */
+    countryName: string;
+    /** Other cities in the zone, joined with `', '`. */
+    cities: string;
+}
+/** A group of zones rendered under one label. */
+interface KbqTimezoneGroup {
+    /** Label of the group: a country name, or the "other countries" label of an aggregate bucket. */
+    countryName: string;
+    /**
+     * Country the group stands for, or `null` for an aggregate bucket that spans several countries
+     * (the one `collapseOtherCountries` produces).
+     */
+    countryCode: string | null;
+    /** Zones of the group, sorted by offset and then by city. */
+    zones: KbqTimezoneZone[];
+}
+/** Zones bucketed by country code, the intermediate shape of the grouping utilities. */
+interface KbqTimezonesByCountry {
+    [countryCode: string]: KbqTimezoneZone[];
+}
+
+declare class KbqTimezoneOption extends KbqOption {
+    readonly tooltipContentWrapper: i0.Signal<ElementRef<HTMLElement>>;
+    readonly tooltipContent: i0.Signal<ElementRef<HTMLElement>>;
+    readonly highlightText: i0.InputSignal<string | readonly string[]>;
+    /** Whether `highlightText` was matched with diacritic folding (e.g. via `createSearchPredicate`) — see `kbqHighlightBackground`. */
+    readonly foldDiacritics: i0.InputSignal<boolean>;
+    /** @docs-private */
+    readonly timezoneInput: i0.InputSignal<KbqTimezoneZone>;
+    /** The time zone the option stands for. */
+    get timezone(): KbqTimezoneZone;
+    /** The id of the time zone, unless no time zone is bound. */
+    get value(): string;
+    /** Offset the bound zone is on right now, written the way `KbqTimezoneZone.offset` is. */
+    protected get resolvedOffset(): string;
+    /** The whole zone as one line: the offset, the city and every city the zone covers. */
+    get viewValue(): string;
+    /**
+     * The same line as `viewValue`, but with the city list narrowed by `highlightText` exactly as the
+     * rendered list is. The overflow tooltip shows this one, so it never lists a city the search has just
+     * filtered out of the option under it.
+     */
+    get tooltipViewValue(): string;
+    /**
+     * The city, which is what typeahead matches. `viewValue` opens with the offset, so every option would
+     * start with `UTC` and typing a city's first letters would never move past the first one — and a zone west
+     * of UTC is written with U+2212, which a keyboard cannot type at all.
+     */
+    getLabel(): string;
+    private buildViewValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneOption, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTimezoneOption, "kbq-timezone-option", ["kbqTimezoneOption"], { "highlightText": { "alias": "highlightText"; "required": false; "isSignal": true; }; "foldDiacritics": { "alias": "foldDiacritics"; "required": false; "isSignal": true; }; "timezoneInput": { "alias": "timezone"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Rows of the city list an option shows before it clamps. Kept in step with the `-webkit-line-clamp` of
+ * `.kbq-timezone-option__cities`.
+ *
+ * @docs-private
+ */
+declare const TOOLTIP_VISIBLE_ROWS_COUNT = 3;
+declare class KbqTimezoneOptionTooltip extends KbqTooltipTrigger implements AfterViewInit, OnDestroy {
+    private readonly option;
+    private readonly resizeObserver;
+    private readonly contentObserver;
+    private readonly platform;
+    private readonly debounceInterval;
+    private resizeSubscription;
+    private contentObserverSubscription;
+    private focusMonitorSubscription;
+    /**
+     * Overrides the tooltip's hoverable default. The overflow hint floats over the neighbouring options of a
+     * scrolling list, so a pointer-capturing pane would swallow the click that selects them.
+     */
+    readonly ignoreTooltipPointerEvents: i0.InputSignal<boolean>;
+    /**
+     * The hint shows rows the option had to clip, so `kbqTooltipDisabled="false"` cannot conjure one for an
+     * option that fits.
+     *
+     * @docs-private
+     */
+    protected readonly derivedDisabledWins = true;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    handleElementEnter(): void;
+    handleElementLeave(): void;
+    /**
+     * Derived rather than assigned: writing `disabled` directly would be read back as the consumer's own
+     * `kbqTooltipDisabled` (see `KbqTooltipTrigger.setDerivedDisabled`), so a later measurement could
+     * silently overwrite an explicit binding and vice versa. `applyDisabled` already no-ops when the folded
+     * value is unchanged, so a resize frame that reports the same line count still costs nothing extra.
+     */
+    private checkTooltipDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneOptionTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTimezoneOptionTooltip, "kbq-timezone-option", never, { "ignoreTooltipPointerEvents": { "alias": "ignoreTooltipPointerEvents"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class KbqTimezoneSelectTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneSelectTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTimezoneSelectTrigger, "kbq-timezone-select-trigger", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Returns an exception to be thrown when `multiple` or `multiline` is turned on for a timezone select, which renders one
+ * value in its trigger and has no multi-selection template behind it.
+ *
+ * @docs-private
+ */
+declare function getKbqTimezoneSelectMultipleError(): Error;
+/**
+ * default configuration of timezone
+ *
+ * @docs-private
+ */
+declare const KBQ_TIMEZONE_DEFAULT_LOCALE_CONFIGURATION: KbqTimezoneLocaleConfiguration;
+/**
+ * Injection Token for providing the default configuration of timezone
+ *
+ * @docs-private
+ */
+declare const KBQ_TIMEZONE_LOCALE_CONFIGURATION: InjectionToken<KbqTimezoneLocaleConfiguration>;
+/**
+ * Utility provider for `KBQ_TIMEZONE_LOCALE_CONFIGURATION`. Only the strings you pass are overridden; the rest keep
+ * following the active locale.
+ */
+declare const kbqTimezoneLocaleConfigurationProvider: (configuration: KbqDeepPartial<KbqTimezoneLocaleConfiguration>) => Provider;
+declare class KbqTimezoneSelect extends KbqSelect {
+    readonly customTrigger: i0.Signal<KbqTimezoneSelectTrigger | undefined>;
+    /** Strings currently rendered by the select. */
+    readonly timezoneLocaleConfiguration: i0.Signal<KbqTimezoneLocaleConfiguration>;
+    /** Form field of the search, whose control carries the placeholder. */
+    private readonly searchFormField;
+    /**
+     * Placeholder this component last wrote into the search. Compared by value: the search control reads back
+     * whatever it carries, and a placeholder the consumer binds after the first render replaces this one.
+     */
+    private appliedLocalePlaceholder;
+    constructor();
+    /**
+     * Rejects `multiple` and `multiline`, which switches the select to multiple selection just the same: the
+     * trigger renders a single value and the panel has no tag list or pseudo-checkboxes behind it. This is the
+     * last point before the selection model is built from them, and `KbqSelect` refuses a later change of
+     * `multiple` on its own.
+     */
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTimezoneSelect, "kbq-timezone-select", ["kbqTimezoneSelect"], {}, {}, ["customTrigger", "searchFormField"], ["kbq-select-matcher, [kbq-select-matcher]", "kbq-timezone-select-trigger", "kbq-cleaner", "[kbqSelectSearch]", "[kbq-select-search-empty-result]", "*", "kbq-select-footer,[kbq-select-footer]"], true, never>;
+}
+
+/** Splits an `HH:MM:SS` offset into the `UTC` prefix and the signed offset, for a two-column layout. */
+declare class UtcOffsetPipe implements PipeTransform {
+    transform(value: string): {
+        [UTC: string]: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtcOffsetPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UtcOffsetPipe, "utcOffset", true>;
+}
+
+declare class KbqTimezoneModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTimezoneModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTimezoneModule, never, [typeof UtcOffsetPipe, typeof CitiesByFilterPipe, typeof KbqTimezoneSelect, typeof KbqTimezoneOption, typeof KbqTimezoneOptionTooltip, typeof KbqTimezoneSelectTrigger], [typeof UtcOffsetPipe, typeof CitiesByFilterPipe, typeof KbqTimezoneSelect, typeof KbqTimezoneOption, typeof KbqTimezoneOptionTooltip, typeof KbqTimezoneSelectTrigger, typeof i6.KbqOptionModule, typeof i7.KbqFormFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTimezoneModule>;
+}
+
+/**
+ * Convert string timezone offset (formatted offset) to number (minutes)
+ */
+declare function parseOffset(offset: string): number;
+/**
+ * Offset `zone` is on at `timestamp`, written the way {@link KbqTimezoneZone.offset} is, or an empty string
+ * when the zone identifies neither a fixed offset nor a time zone `Intl` knows.
+ *
+ * A zone that carries an explicit `offset` keeps that string verbatim. A zone without one has the offset
+ * resolved from its IANA `id`, which is what makes a DST zone read `UTC+01:00` in January and `UTC+02:00`
+ * in July instead of whichever of the two was written into the data.
+ */
+declare function resolveZoneOffset(zone: KbqTimezoneZone, timestamp?: number): string;
+/**
+ * Groups zones by {@link KbqTimezoneZone.countryCode} — one group per country, ordered by country name,
+ * with the zones inside each group ordered by {@link timezonesSortComparator}.
+ *
+ * Pure: the same input produces the same groups on any machine, which is what makes it safe to run on the
+ * server and again in the browser. To put the user's own country first, pass the result through
+ * {@link promoteCountry} or {@link collapseOtherCountries}, and read the country itself with
+ * {@link kbqResolveHostCountry}.
+ */
+declare function getZonesGroupedByCountry(data: readonly KbqTimezoneZone[]): KbqTimezoneGroup[];
+/**
+ * Moves the group of `countryCode` to the front, leaving the rest in their order. Returns a new array; a
+ * country the groups do not contain, or no country at all, leaves the order untouched.
+ */
+declare function promoteCountry(groups: readonly KbqTimezoneGroup[], countryCode: string | null | undefined): KbqTimezoneGroup[];
+/**
+ * Merges every group other than `countryCode` into one bucket labelled `otherCountriesLabel`, placed after
+ * the country it promotes. The bucket spans countries, so its `countryCode` is `null`.
+ *
+ * This is the shape a world-wide list is usually rendered in: the user's own country first, everything else
+ * collapsed behind one label.
+ */
+declare function collapseOtherCountries(groups: readonly KbqTimezoneGroup[], countryCode: string | null | undefined, otherCountriesLabel: string): KbqTimezoneGroup[];
+/**
+ * Country code of the zone whose `id` is the time zone of the machine this runs on, or `undefined` when
+ * `data` has no row for it.
+ *
+ * Reads `Intl`, so the answer is the host's: on the server that is the server's zone rather than the user's,
+ * and the value it produces there will not match the one the browser produces on hydration. It is kept
+ * apart from the grouping for exactly that reason — call it where host-dependence is acceptable and pass
+ * the result on.
+ */
+declare function kbqResolveHostCountry(data: readonly KbqTimezoneZone[]): string | undefined;
+/** Formats an `HH:MM:SS` offset as a signed `±HH:MM`, with U+2212 for the minus sign. */
+declare function offset(value: string): string;
+/** Formats an `HH:MM:SS` offset the way the option renders it: `UTC+03:00`. */
+declare function offsetFormatter(value: string): string;
+/** The same as {@link offsetFormatter}, split into the `UTC` prefix and the offset for two-column layouts. */
+declare function offsetFormatterAsObject(value: string): {
+    [UTC: string]: string;
+};
+/**
+ * Comparator for timezone sorting. Orders by the offset each zone is on right now, then by city name — the
+ * country cannot discriminate here, since every zone reaching this inside a group already shares one.
+ *
+ * A zone whose offset resolves to nothing sorts after every zone that has one, rather than as UTC.
+ */
+declare function timezonesSortComparator(first: KbqTimezoneZone, second: KbqTimezoneZone): number;
+/**
+ * Filtering timezone cities by search string. Accepts a single pattern or several (matching a
+ * city if it satisfies any one of them) — patterns that look like a bare UTC offset (e.g. `+3`)
+ * are ignored here, since they describe the zone rather than a city name.
+ */
+declare function filterCitiesBySearchString(cities: string, searchPattern?: string | readonly string[]): string;
+
+export { CitiesByFilterPipe, KBQ_TIMEZONE_DEFAULT_LOCALE_CONFIGURATION, KBQ_TIMEZONE_LOCALE_CONFIGURATION, KbqTimezoneModule, KbqTimezoneOption, KbqTimezoneOptionTooltip, KbqTimezoneSelect, KbqTimezoneSelectTrigger, TOOLTIP_VISIBLE_ROWS_COUNT, UtcOffsetPipe, collapseOtherCountries, filterCitiesBySearchString, getKbqTimezoneSelectMultipleError, getZonesGroupedByCountry, kbqResolveHostCountry, kbqTimezoneLocaleConfigurationProvider, offset, offsetFormatter, offsetFormatterAsObject, parseOffset, promoteCountry, resolveZoneOffset, timezonesSortComparator };
+export type { KbqTimezoneGroup, KbqTimezoneZone, KbqTimezonesByCountry };