iss-ctrl 0.0.21 → 0.0.23

package/types/iss-ctrl-base.d.ts

@@ -0,0 +1,318 @@
+import * as i0 from '@angular/core';
+import { InputSignal, WritableSignal, OutputEmitterRef, Provider, PipeTransform } from '@angular/core';
+import { ControlValueAccessor, Validator, FormControl, AbstractControl, ValidationErrors, NgControl } from '@angular/forms';
+import { ErrorStateMatcher, MatDateFormats, NativeDateAdapter } from '@angular/material/core';
+
+type HintAlignment = "start" | "end";
+interface Hint {
+    key: string;
+    label: string;
+    valid: boolean | undefined;
+    align: HintAlignment;
+}
+
+/**
+ * Base class for every `iss-ctrl-*` control.
+ *
+ * Controls are the presentational layer: they know nothing about {@link IssField} and are
+ * driven purely by bindings, so they can be used standalone inside any reactive form.
+ * Every control below inherits the properties declared here and adds its own on top.
+ *
+ * ### Inherited inputs
+ * | Property | Type | Default | Description |
+ * | --- | --- | --- | --- |
+ * | `formControlName` | `string` | `""` | Name of the control in the surrounding `FormGroup`. |
+ * | `placeholder` | `string` | `""` | Placeholder text shown while the field is empty. |
+ * | `readonly` | `boolean` | `false` | Renders the value but blocks every interaction. |
+ * | `multiple` | `boolean \| undefined` | `false` | Allows more than one value, where the control supports it. |
+ * | `min` | `number \| string \| null` | `null` | Lower bound (number or date/time string). |
+ * | `max` | `number \| string \| null` | `null` | Upper bound (number or date/time string). |
+ * | `minLength` | `number \| null` | `null` | Minimum number of characters. |
+ * | `maxLength` | `number \| null` | `null` | Maximum number of characters. |
+ * | `hints` | `Hint[]` | `[]` | Helper messages rendered under the field. |
+ * | `className` | `string \| null` | `null` | Extra CSS classes for the host. |
+ *
+ * ### Inherited outputs
+ * | Event | Payload | Description |
+ * | --- | --- | --- |
+ * | `(onChange)` | `any` | Fires after every committed value change. |
+ *
+ * ### Not inputs
+ * `disabled` and `touched` are signals owned by the control. Disable a control through the
+ * forms API (`ctrl.disable()` or a `disabled` field config), never with a template binding.
+ *
+ * ### Content projection
+ * Controls that render a `mat-form-field` project `<label>` into the floating label.
+ * `upgrade.scss` reveals that space only while the projected `<label>` carries text, so an
+ * omitted label — or one that interpolates to an empty string — collapses it. No label markup
+ * is removed at runtime, so a label that arrives later simply shows up.
+ *
+ * @example
+ * ```html
+ * <iss-ctrl-input formControlName="email" [readonly]="false" (onChange)="save($event)">
+ *   <label>Email</label>
+ * </iss-ctrl-input>
+ * ```
+ */
+declare class ControlBase implements ControlValueAccessor, Validator {
+    #private;
+    /**
+     * Name of this control inside the surrounding `FormGroup`.
+     */
+    formControlName: InputSignal<string>;
+    /**
+     * Lower bound forwarded to the underlying input — a number, or a date/time string.
+     */
+    min: InputSignal<number | string | null>;
+    /**
+     * Upper bound forwarded to the underlying input — a number, or a date/time string.
+     */
+    max: InputSignal<number | string | null>;
+    /**
+     * Minimum number of characters accepted by the underlying input.
+     */
+    minLength: InputSignal<number | null>;
+    /**
+     * Maximum number of characters accepted by the underlying input.
+     */
+    maxLength: InputSignal<number | null>;
+    /**
+     * Disabled state. **Not an input** — it is set by the forms API through
+     * {@link ControlBase.setDisabledState}. Disable via `ctrl.disable()` or the field config.
+     */
+    disabled: WritableSignal<boolean>;
+    /**
+     * Renders the current value but blocks every user interaction.
+     */
+    readonly: InputSignal<boolean>;
+    /**
+     * Allows selecting/entering more than one value, on controls that support it.
+     */
+    multiple: InputSignal<boolean | undefined>;
+    /**
+     * Placeholder text shown while the control has no value.
+     */
+    placeholder: InputSignal<string>;
+    /**
+     * Helper messages rendered beneath the field. See {@link Hint}.
+     */
+    hints: InputSignal<Hint[]>;
+    /**
+     * Extra CSS class names applied to the control host.
+     */
+    className: InputSignal<string | null>;
+    /**
+     * Whether the user has interacted with the control. Owned by the control, not an input.
+     */
+    touched: WritableSignal<boolean>;
+    /**
+     * Emits the committed value after every change.
+     */
+    onChange: OutputEmitterRef<any>;
+    protected ctrl: FormControl;
+    /**
+     * Error state for the inner `mat-form-field`, derived from the **host** control.
+     *
+     * Material reads `errorState` off the `NgControl` bound to its own `matInput` — here that is
+     * {@link ControlBase.ctrl}, which carries no validators and is therefore always valid. Every
+     * error a consumer cares about (the field config's validators plus the control's own
+     * {@link ControlBase.validate}) lives on the host control instead, so without this matcher an
+     * invalid `iss-ctrl-*` would keep rendering the valid outline. Bind it on the `matInput` as
+     * `[errorStateMatcher]="errorStateMatcher"`.
+     */
+    protected errorStateMatcher: ErrorStateMatcher;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: string | FormData | Date | null): void;
+    markAsTouched(): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    /**
+     * The `NgControl` this component is bound to from the outside (`formControlName`,
+     * `[formControl]` or `[ngModel]`), or `null` when it is used without one.
+     */
+    protected hostControl(): NgControl | null;
+    /**
+     * Whether the control currently holds no value.
+     *
+     * Reflected on the host as `iss-ctrl-empty`, which is what `upgrade.scss` uses to keep the
+     * resting outline of an empty field: Material's own `mat-form-field-hide-placeholder` drops
+     * off the moment the field is focused, so the border would change colour on focus alone.
+     * Override it in a control whose value does not live on {@link ControlBase.ctrl}.
+     */
+    protected isEmpty(): boolean;
+    protected onTouch: () => void;
+    protected onPropagateValue: (_: any) => void;
+    protected emitValue(value?: any): void;
+    protected propagateValue(value?: any): void;
+    protected emitOnChangeEvent($event?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlBase, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ControlBase, "ng-component", never, { "formControlName": { "alias": "formControlName"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "hints": { "alias": "hints"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, { "onChange": "onChange"; }, never, never, true, never>;
+}
+
+declare const DATE_FORMAT_ADAPTER: MatDateFormats;
+declare const DATETIME_FORMAT = "dd/MM/yyyy hh:mm a";
+
+/**
+ * Umm al-Qura Hijri calendar helpers.
+ *
+ * Every function here works on a plain `Date`: a `Date` is an instant, and the Hijri
+ * calendar is only another way of naming that instant. Nothing stores Hijri numbers on the
+ * date itself, so a value converted to Hijri for display or emission is still the same day.
+ *
+ * The conversion is done by `Intl` with the `islamic-umalqura` calendar, which is the
+ * calendar used officially in Saudi Arabia.
+ */
+/** Locale used by the calendar UI when the Hijri calendar is on. */
+declare const HIJRI_LOCALE = "ar-SA-u-ca-islamic-umalqura";
+declare const HIJRI_MONTH_NAMES: {
+    ar: string[];
+    en: string[];
+    enShort: string[];
+};
+interface HijriParts {
+    /** Hijri year, for example `1447`. */
+    year: number;
+    /** Hijri month, **zero based** like `Date.getMonth()` — `0` is Muharram. */
+    month: number;
+    /** Hijri day of month, starting at `1`. */
+    day: number;
+}
+/**
+ * Reads the Hijri year, month and day a `Date` falls on.
+ */
+declare function getHijriParts(date: Date): HijriParts;
+/**
+ * The Gregorian `Date` of the first day of the Hijri month `date` falls in, at midday.
+ *
+ * Midday, not midnight, so a daylight-saving shift can never push the result into the
+ * previous day while the month is being walked.
+ */
+declare function startOfHijriMonth(date: Date): Date;
+/**
+ * Number of days in the Hijri month `date` falls in — 29 or 30, decided by Umm al-Qura.
+ */
+declare function getHijriDaysInMonth(date: Date): number;
+/**
+ * Builds the `Date` for a Hijri year/month/day. The month is zero based, and a day past the
+ * end of the month is clamped to the last day of that month.
+ */
+declare function createHijriDate(year: number, month: number, day: number): Date;
+/**
+ * Formats a date as a Hijri `yyyy-MM-dd` string — the shape the form emits when
+ * `emitHijri` is on.
+ */
+declare function formatHijriDate(date: Date): string;
+/**
+ * Reads a Hijri date back into a `Date`, accepting both the emitted `yyyy-MM-dd` shape and
+ * the `dd/MM/yyyy` shape shown in the input. Returns `null` for anything else.
+ */
+declare function parseHijriDate(value: string | null | undefined): Date | null;
+/**
+ * Renders a stored form value as a Hijri `dd/MM/yyyy` string for the read-only viewers, or
+ * returns `null` when the field is not on the Hijri calendar and the value should be shown
+ * as an ordinary Gregorian date.
+ *
+ * The two Hijri modes store different things, so they are read differently: with `emitHijri`
+ * the value already carries Hijri numbers and only its notation changes, while with
+ * `hijriCalendar` alone the value is Gregorian and has to be converted.
+ */
+declare function toHijriDisplay(value: string | null | undefined, options: {
+    hijriCalendar?: boolean;
+    emitHijri?: boolean;
+    withTime?: boolean;
+}): string | null;
+
+declare class Hints {
+    hints: InputSignal<Hint[]>;
+    touched: InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Hints, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Hints, "iss-ctrl-hints", never, { "hints": { "alias": "hints"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface I18n {
+    ar: string | null | undefined;
+    en: string | null | undefined;
+}
+
+/**
+ * The single date adapter behind every `iss-ctrl-*` picker.
+ *
+ * It behaves as a plain Gregorian adapter — `dd/MM/yyyy` in and out — until its locale is
+ * switched to {@link HIJRI_LOCALE}, at which point the whole calendar grid becomes Umm
+ * al-Qura Hijri: the month lengths, the year and month labels and the day numbers all come
+ * from the Hijri calendar.
+ *
+ * The value never changes shape. The adapter always works on a `Date`, so a Hijri calendar
+ * still hands the control an ordinary `Date`, and it stays the control's decision whether to
+ * emit that as a Gregorian or a Hijri string.
+ *
+ * Switch modes through {@link setHijri}, never by assigning `locale` — `setLocale` is what
+ * tells an open calendar to re-render.
+ */
+declare class IssDateAdapter extends NativeDateAdapter {
+    #private;
+    /** The Gregorian locale to fall back to when the Hijri calendar is turned off. */
+    gregorianLocale: string;
+    /** Whether the adapter is currently presenting the Hijri calendar. */
+    get isHijri(): boolean;
+    /**
+     * Turns the Hijri calendar on or off. Goes through `setLocale` so that a calendar that is
+     * already open redraws itself.
+     */
+    setHijri(hijri: boolean): void;
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDate(date: Date): number;
+    getMonthNames(style: "long" | "short" | "narrow"): string[];
+    getDateNames(): string[];
+    getDayOfWeekNames(style: "long" | "short" | "narrow"): string[];
+    getYearName(date: Date): string;
+    getFirstDayOfWeek(): number;
+    getNumDaysInMonth(date: Date): number;
+    createDate(year: number, month: number, date: number): Date;
+    addCalendarYears(date: Date, years: number): Date;
+    addCalendarMonths(date: Date, months: number): Date;
+    addCalendarDays(date: Date, days: number): Date;
+    parse(value: any, parseFormat?: any): Date | null;
+    format(date: Date, displayFormat: string): string;
+    deserialize(value: any): Date | null;
+    toIso8601(date: Date): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IssDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IssDateAdapter>;
+}
+/**
+ * Providers every date-based control needs: the {@link IssDateAdapter} itself, the Gregorian
+ * locale it falls back to, and the `dd/MM/yyyy` formats both of its calendars are rendered in.
+ *
+ * Declared per component, so each picker owns its adapter instance and one field switching to
+ * the Hijri calendar leaves every other field on the form alone.
+ */
+declare function provideIssDateAdapter(): Provider[];
+
+interface Option {
+    value: string;
+    title: string | I18n | undefined;
+}
+
+declare class SelectStatusPipe implements PipeTransform {
+    transform(option: Option, ...args: unknown[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectStatusPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SelectStatusPipe, "selectStatus", true>;
+}
+
+declare class TranslatePipe implements PipeTransform {
+    currentLanguage: string;
+    transform(value: I18n | string | null | undefined, locale?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TranslatePipe, "translate", true>;
+}
+
+declare class ViewerBase {
+    field: InputSignal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerBase, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewerBase, "ng-component", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ControlBase, DATETIME_FORMAT, DATE_FORMAT_ADAPTER, HIJRI_LOCALE, HIJRI_MONTH_NAMES, Hints, IssDateAdapter, SelectStatusPipe, TranslatePipe, ViewerBase, createHijriDate, formatHijriDate, getHijriDaysInMonth, getHijriParts, parseHijriDate, provideIssDateAdapter, startOfHijriMonth, toHijriDisplay };
+export type { HijriParts, Hint, HintAlignment, I18n, Option };

package/types/iss-ctrl-checkbox.d.ts

@@ -0,0 +1,46 @@
+import * as i0 from '@angular/core';
+import { InputSignal, WritableSignal } from '@angular/core';
+import { ControlBase, Option } from 'iss-ctrl/base';
+
+/**
+ * `<iss-ctrl-checkbox>` — a list of checkboxes over a fixed set of options.
+ *
+ * The form value is the comma separated list of selected option values, while `(onChange)`
+ * emits the resolved `Option[]` (or `null` when nothing is selected).
+ *
+ * @example
+ * ```html
+ * <iss-ctrl-checkbox formControlName="days" [options]="days" (onChange)="pick($event)"/>
+ * ```
+ *
+ * ### Own inputs
+ * | Property | Type | Default | Description |
+ * | --- | --- | --- | --- |
+ * | `options` | `Option[]` | **required** | The selectable choices. |
+ *
+ * ### Inherited from {@link ControlBase}
+ * `formControlName` · `readonly` · `className` · `(onChange)`
+ *
+ * Projected content is rendered above the list — the wrapping `iss-field-*` passes the
+ * field label in that way.
+ */
+declare class CheckboxControl extends ControlBase {
+    #private;
+    /**
+     * Selectable choices, each a `{ value, title }` pair. Required.
+     */
+    options: InputSignal<Option[]>;
+    /**
+     * Currently checked options, keyed by value. Internal state, not an input.
+     */
+    selectedOptions: WritableSignal<Map<string, Option>>;
+    writeValue(value: string | null): void;
+    addToSelectedOptionsMap(option: Map<string, Option>): void;
+    onCheckboxChange(checked: boolean, value: string): void;
+    stringifySelectedOptions(): string | null;
+    getEmissionValue(options: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxControl, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxControl, "iss-ctrl-checkbox", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; }, {}, never, ["label"], true, never>;
+}
+
+export { CheckboxControl };

package/types/iss-ctrl-chips.d.ts

@@ -0,0 +1,41 @@
+import * as i0 from '@angular/core';
+import { WritableSignal } from '@angular/core';
+import { MatChipInputEvent } from '@angular/material/chips';
+import { ControlBase } from 'iss-ctrl/base';
+
+/**
+ * `<iss-ctrl-chips>` — free text entered as removable chips.
+ *
+ * Each `Enter` turns the typed text into a chip. The form value is the comma separated list
+ * of chip labels.
+ *
+ * @example
+ * ```html
+ * <iss-ctrl-chips formControlName="tags" placeholder="Add a tag">
+ *   <label>Tags</label>
+ * </iss-ctrl-chips>
+ * ```
+ *
+ * ### Own inputs
+ * None — the control is configured entirely through the inherited properties.
+ *
+ * ### Inherited from {@link ControlBase}
+ * `formControlName` · `readonly` · `className` · `(onChange)` · `placeholder`
+ *
+ * Projects `<label>` into the floating label; omit it to render the control without one.
+ */
+declare class ChipsControl extends ControlBase {
+    #private;
+    /**
+     * The chips currently rendered. Internal state, not an input.
+     */
+    readonly keywords: WritableSignal<string[]>;
+    writeValue(value: string | null): void;
+    remove(keyword: string): void;
+    add(event: MatChipInputEvent): void;
+    protected isEmpty(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChipsControl, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChipsControl, "iss-ctrl-chips", never, {}, {}, never, ["label"], true, never>;
+}
+
+export { ChipsControl };

package/types/iss-ctrl-date-picker.d.ts

@@ -0,0 +1,75 @@
+import * as i0 from '@angular/core';
+import { InputSignal } from '@angular/core';
+import { Validator } from '@angular/forms';
+import { MatDatepickerInputEvent } from '@angular/material/datepicker';
+import { ControlBase } from 'iss-ctrl/base';
+
+/**
+ * `<iss-ctrl-date-picker>` — single date selection through a Material calendar.
+ *
+ * The input itself is read-only; clicking it opens the calendar. The emitted value is a
+ * `yyyy-MM-dd` string, and a clear button appears once a date is picked.
+ *
+ * @example
+ * ```html
+ * <iss-ctrl-date-picker formControlName="startsOn" [minDate]="today" [disabledDays]="[5, 6]">
+ *   <label>Start date</label>
+ * </iss-ctrl-date-picker>
+ * ```
+ *
+ * ### Own inputs
+ * | Property | Type | Default | Description |
+ * | --- | --- | --- | --- |
+ * | `minDate` | `Date \| null` | `null` | Earliest selectable date. |
+ * | `maxDate` | `Date \| null` | `null` | Latest selectable date. |
+ * | `disabledDays` | `number[]` | `[]` | Week days to block, `0` = Sunday … `6` = Saturday. |
+ * | `hijriCalendar` | `boolean` | `false` | Shows an Umm al-Qura Hijri calendar; the value stays Gregorian. |
+ * | `emitHijri` | `boolean` | `false` | Emits the Hijri date instead of the Gregorian one. Implies `hijriCalendar`. |
+ *
+ * ### Hijri dates
+ * `hijriCalendar` only changes what the user sees: the calendar is Hijri, the input reads
+ * `dd/MM/yyyy` in Hijri, and a day shown as `16/03/1447` is still emitted as `2025-09-08`.
+ * Turn on `emitHijri` as well when the form value itself has to be the Hijri date. `minDate` and
+ * `maxDate` stay Gregorian in both cases — they are bounds on a day, not on a notation.
+ *
+ * ### Inherited from {@link ControlBase}
+ * `formControlName` · `readonly` · `className` · `(onChange)`
+ *
+ * Projects `<label>` into the floating label; omit it to render the control without one.
+ */
+declare class DatePickerControl extends ControlBase implements Validator {
+    #private;
+    /**
+     * Week days that cannot be selected — `0` is Sunday through `6` for Saturday.
+     */
+    disabledDays: InputSignal<number[]>;
+    /**
+     * Earliest selectable date.
+     */
+    minDate: InputSignal<Date | null>;
+    /**
+     * Latest selectable date.
+     */
+    maxDate: InputSignal<Date | null>;
+    /**
+     * Renders the calendar as an Umm al-Qura Hijri calendar, leaving the emitted value Gregorian.
+     */
+    hijriCalendar: InputSignal<boolean>;
+    /**
+     * Emits the picked date as a Hijri `yyyy-MM-dd` string. Implies {@link hijriCalendar}.
+     */
+    emitHijri: InputSignal<boolean>;
+    /**
+     * Whether this picker is currently showing the Hijri calendar.
+     */
+    isHijri(): boolean;
+    writeValue(value: string | Date | null): void;
+    clear(event: MouseEvent): void;
+    protected calendarDaysFilter: (d: Date | null) => boolean;
+    protected emit($event: MatDatepickerInputEvent<any>): void;
+    protected openPicker(picker: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerControl, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerControl, "iss-ctrl-date-picker", never, { "disabledDays": { "alias": "disabledDays"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "hijriCalendar": { "alias": "hijriCalendar"; "required": false; "isSignal": true; }; "emitHijri": { "alias": "emitHijri"; "required": false; "isSignal": true; }; }, {}, never, ["label"], true, never>;
+}
+
+export { DatePickerControl };

package/types/iss-ctrl-date-range-picker.d.ts

@@ -0,0 +1,95 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, InputSignal, OutputEmitterRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ControlBase } from 'iss-ctrl/base';
+
+interface DateRangeEmission {
+    duration: number;
+    start: string;
+    end: string;
+}
+
+/**
+ * `<iss-ctrl-date-range-picker>` — a start/end date range in one field.
+ *
+ * A half-filled range is not a value: clearing either endpoint clears the form value and
+ * emits `null`. The form value is a `yyyy-MM-dd` string pair; `(onDateRangeObjectChange)`
+ * emits the same range as a {@link DateRangeEmission} object.
+ *
+ * @example
+ * ```html
+ * <iss-ctrl-date-range-picker formControlName="period" (onDateRangeObjectChange)="apply($event)">
+ *   <label>Period</label>
+ * </iss-ctrl-date-range-picker>
+ * ```
+ *
+ * ### Own inputs
+ * | Property | Type | Default | Description |
+ * | --- | --- | --- | --- |
+ * | `minDate` | `Date \| null` | `null` | Earliest selectable date. |
+ * | `maxDate` | `Date \| null` | `null` | Latest selectable date. |
+ * | `disabledDays` | `number[]` | `[]` | Week days to block, `0` = Sunday … `6` = Saturday. |
+ * | `hijriCalendar` | `boolean` | `false` | Shows an Umm al-Qura Hijri calendar; the value stays Gregorian. |
+ * | `emitHijri` | `boolean` | `false` | Emits both endpoints as Hijri dates. Implies `hijriCalendar`. |
+ *
+ * ### Hijri dates
+ * `hijriCalendar` only changes what the user sees; the emitted range stays Gregorian until
+ * `emitHijri` is on as well, at which point both endpoints carry Hijri dates. `duration` is
+ * a count of days either way, and `minDate`/`maxDate` stay Gregorian.
+ *
+ * ### Inherited from {@link ControlBase}
+ * `formControlName` · `readonly` · `className` · `(onChange)`
+ *
+ * ### Outputs
+ * - `(onDateRangeObjectChange)` — `DateRangeEmission | null`, the range as an object.
+ *
+ * Projects `<label>` into the floating label; omit it to render the control without one.
+ */
+declare class DateRangePickerControl extends ControlBase implements OnInit, OnDestroy {
+    #private;
+    /**
+     * Week days that cannot be selected — `0` is Sunday through `6` for Saturday.
+     */
+    disabledDays: InputSignal<number[]>;
+    /**
+     * Earliest selectable date.
+     */
+    minDate: InputSignal<Date | null>;
+    /**
+     * Latest selectable date.
+     */
+    maxDate: InputSignal<Date | null>;
+    /**
+     * Renders the calendar as an Umm al-Qura Hijri calendar, leaving the emitted range Gregorian.
+     */
+    hijriCalendar: InputSignal<boolean>;
+    /**
+     * Emits both endpoints as Hijri dates. Implies {@link hijriCalendar}.
+     */
+    emitHijri: InputSignal<boolean>;
+    /**
+     * Emits the selected range as an object, or `null` while the range is incomplete.
+     */
+    onDateRangeObjectChange: OutputEmitterRef<DateRangeEmission | null>;
+    /**
+     * The `start`/`end` form group backing the range input. Internal state.
+     */
+    readonly range: FormGroup;
+    /**
+     * Whether this picker is currently showing the Hijri calendar.
+     */
+    isHijri(): boolean;
+    ngOnInit(): void;
+    setDisabledState(isDisabled: boolean): void;
+    clear(event: MouseEvent): void;
+    writeValue(value: string | FormData | null): void;
+    ngOnDestroy(): void;
+    protected isEmpty(): boolean;
+    protected openPicker(picker: any): void;
+    protected calendarDaysFilter: (d: Date | null) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePickerControl, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangePickerControl, "iss-ctrl-date-range-picker", never, { "disabledDays": { "alias": "disabledDays"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "hijriCalendar": { "alias": "hijriCalendar"; "required": false; "isSignal": true; }; "emitHijri": { "alias": "emitHijri"; "required": false; "isSignal": true; }; }, { "onDateRangeObjectChange": "onDateRangeObjectChange"; }, never, ["label"], true, never>;
+}
+
+export { DateRangePickerControl };
+export type { DateRangeEmission };

package/types/iss-ctrl-datetime-picker.d.ts

@@ -0,0 +1,77 @@
+import * as i0 from '@angular/core';
+import { InputSignal } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ControlBase } from 'iss-ctrl/base';
+
+/**
+ * `<iss-ctrl-datetime-picker>` — a date and a time in a single field.
+ *
+ * Combines the calendar of the date picker with the time list of the time picker; both parts
+ * must be set before a value is emitted.
+ *
+ * @example
+ * ```html
+ * <iss-ctrl-datetime-picker formControlName="scheduledAt" [minDate]="today" minTime="08:00" maxTime="17:00">
+ *   <label>Scheduled at</label>
+ * </iss-ctrl-datetime-picker>
+ * ```
+ *
+ * ### Own inputs
+ * | Property | Type | Default | Description |
+ * | --- | --- | --- | --- |
+ * | `minDate` | `Date \| null` | `null` | Earliest selectable date. |
+ * | `maxDate` | `Date \| null` | `null` | Latest selectable date. |
+ * | `minTime` | `string \| null` | `null` | Earliest selectable time, `HH:mm`. |
+ * | `maxTime` | `string \| null` | `null` | Latest selectable time, `HH:mm`. |
+ * | `disabledDays` | `number[]` | `[]` | Week days to block, `0` = Sunday … `6` = Saturday. |
+ * | `hijriCalendar` | `boolean` | `false` | Shows an Umm al-Qura Hijri calendar; the value stays Gregorian. |
+ * | `emitHijri` | `boolean` | `false` | Emits the date half as a Hijri date. Implies `hijriCalendar`. |
+ *
+ * ### Hijri dates
+ * Both flags are handed straight to the inner date picker; the time half is untouched, so a
+ * Hijri value reads `1447-03-15T09:30:00`.
+ *
+ * ### Inherited from {@link ControlBase}
+ * `formControlName` · `readonly` · `className` · `(onChange)`
+ *
+ * Projects `<label>` into the floating label; omit it to render the control without one.
+ */
+declare class DatetimePickerControl extends ControlBase {
+    #private;
+    datetimeForm: FormGroup;
+    /**
+     * Week days that cannot be selected — `0` is Sunday through `6` for Saturday.
+     */
+    disabledDays: InputSignal<number[]>;
+    /**
+     * Earliest selectable date.
+     */
+    minDate: InputSignal<Date | null>;
+    /**
+     * Latest selectable date.
+     */
+    maxDate: InputSignal<Date | null>;
+    /**
+     * Earliest selectable time of day, as `HH:mm`.
+     */
+    minTime: InputSignal<string | null>;
+    /**
+     * Latest selectable time of day, as `HH:mm`.
+     */
+    maxTime: InputSignal<string | null>;
+    /**
+     * Renders the calendar as an Umm al-Qura Hijri calendar, leaving the emitted date Gregorian.
+     */
+    hijriCalendar: InputSignal<boolean>;
+    /**
+     * Emits the date half of the value as a Hijri date. Implies {@link hijriCalendar}.
+     */
+    emitHijri: InputSignal<boolean>;
+    setDisabledState(isDisabled: boolean): void;
+    emit(): void;
+    writeValue(value: string | Date | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimePickerControl, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatetimePickerControl, "iss-ctrl-datetime-picker", never, { "disabledDays": { "alias": "disabledDays"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "minTime": { "alias": "minTime"; "required": false; "isSignal": true; }; "maxTime": { "alias": "maxTime"; "required": false; "isSignal": true; }; "hijriCalendar": { "alias": "hijriCalendar"; "required": false; "isSignal": true; }; "emitHijri": { "alias": "emitHijri"; "required": false; "isSignal": true; }; }, {}, never, ["label"], true, never>;
+}
+
+export { DatetimePickerControl };