CSC Design System v4.0.1
VueFlavour Vue React Angular TypeScript
Flavour Vue React Angular TypeScript
PrimaryCSC UI Colors Primary Secondary AccentCustom Colors Red Orange Green Blue Purple Pink
CSC UI Colors Primary Secondary AccentCustom Colors Red Orange Green Blue Purple Pink
Guides Getting started Customization Data visualization Migration guide Componentsc-accordionc-alertc-autocompletec-badgec-breadcrumbc-buttonc-button-groupc-cardc-checkboxc-color-pickerc-csc-logoc-data-tablec-date-pickerc-dividerc-file-uploadc-iconc-icon-buttonc-linkc-listc-loaderc-login-buttonsc-login-cardc-mainc-menuc-messagec-modalc-navigation-buttonc-number-fieldc-otp-inputc-pagec-paginationc-popoverc-progress-barc-progress-circlec-radio-groupc-selectc-side-navigationc-sliderc-spinnerc-statusc-stepsc-switchc-tablec-tabsc-tagsc-text-fieldc-time-pickerc-toastsc-toolbarc-tooltipc-tree-select

<c-date-picker>

A date field that takes a typed date, or opens a calendar panel for picking one, or a start and end date under `range`.

Usage

Value

The value is a calendar date as an ISO YYYY-MM-DD string — '2026-09-28' — or null when the field is empty. It carries no time and no timezone, so it round-trips through attributes, JSON and forms unchanged, and whatever the displayed format, the value keeps this one shape. Bind it with v-model, or listen for change:

<c-date-picker v-model="date" label="Start date" />

Under range the value becomes { start, end }. Picking in the calendar always yields a complete range; typing can commit one end before the other, so either end may be null — { start: '2026-09-01', end: null } — and a range with neither end is null.

Typing

The field is typeable first: clicking into it or focusing it never opens the calendar. Text is read when the user presses Enter or leaves the input, never per keystroke. The format prop sets how dates are shown and read — a pattern of the tokens d, dd, M, MM and yyyy with any separators, dd.MM.yyyy by default. Reading is lenient: a day or a month may have one or two digits whatever the token, and any of ., /, - or a space separates the parts, so 1.9.2026 and 1/9/2026 both commit as 01.09.2026 under the default. The year needs all four digits. The format is an app default, so an app can set it once with applyDefaults({ 'c-date-picker': { format: 'yyyy-MM-dd' } }).

Typing follows the format as it goes: the separators appear on their own (01012031 shows 01.01.2031), a day or month closes early when a separator is typed or when its first digit can start no two-digit value (4 for a day, 2 for a month), any of ., /, - or a space typed in place of a separator shows as the format's own, and other characters are dropped. Pasted text is kept as it is and read when committed.

Text that names no date that can be picked — 31.02.2026, a disabled date, a date outside min and max — is bad input: the text stays as the user typed it, the value becomes null, and the host exposes the bad-input custom state and a read-only badInput property. The component never shows an error of its own; deciding whether bad input is an error, and saying so, is the consumer's validation, and only a <form> without novalidate stops a submit on it:

<c-date-picker
  v-model="date"
  :error-message="error"
  :invalid="!!error"
  label="Start date"
  @change:text="
    error = $event.target.badInput ? 'Enter a date as dd.mm.yyyy' : ''
  "
/>

Every commit of typed text fires change:text with the text as typed ({ start, end } under range), whether or not it changed the value — the moment to read badInput, as above.

The calendar

The calendar button at the field's trailing edge, or Alt+ArrowDown in the input, opens the calendar panel. It is a dialog: focus moves onto the selected day, else today, else the nearest day that can be picked, and Tab cycles through the month and year controls, the grid and the Today button (show-today) until the panel closes. Picking a day commits it and closes the panel; Escape closes it without a change. Focus returns to the input either way. On a narrow viewport a pick waits for a Done button instead (see Narrow viewports).

Key In the day grid
ArrowLeft / ArrowRight Previous / next day
ArrowUp / ArrowDown Same day of the previous / next week
Home / End First / last day of the week
PageUp / PageDown Same day of the previous / next month
Shift+PageUp / PageDown Same day of the previous / next year
Enter / Space Pick the day

The month and year buttons in the header swap the grid for a list of months or years; picking one returns to the grid. The year list reaches a hundred years either side of today unless min and max narrow it. The displayed month is announced to the consumer as change:month ('YYYY-MM') whenever it changes and when the panel opens.

The week starts on Monday; set first-day-of-week to another day, numbered like Date.getDay() (0 for Sunday). show-week-numbers adds ISO 8601 week numbers beside the rows. With a week start other than Monday a row spans two ISO weeks and shows the one holding most of its days, so a week split across two months carries the same number in both.

Ranges

With range the field holds two inputs, the start and the end, in one field box. In the calendar the first day picked is only pending — it is shown and announced, the band follows the pointer or the focused day, and nothing is emitted — until the second pick completes the range and closes the panel. Dismissing the panel in between discards the pending day. Picking the end before the start swaps them, and so does typing a start later than the end.

Disabling dates

Three rules decide which dates cannot be picked; a date any of them rules out is disabled:

  • min and max — ISO dates bounding the calendar itself: the arrows and the keyboard stop there.
  • disabled-dates — a list of ISO dates and inclusive { start, end } spans.
  • is-date-disabled — a predicate receiving an ISO date, for rules such as "no weekends".

The list and the predicate have no attribute form, so bind them as DOM properties. A disabled day can still be focused in the grid — the arrows keep their meaning — and is announced as unavailable, but it cannot be picked. A range may span disabled days: only its start and end must be enabled.

Availability that comes from a server can follow the calendar: load the disabled dates of the month change:month names and assign disabled-dates again.

Months

With type="month" the field picks a year and a month instead of a day. The value is an ISO YYYY-MM string — '2026-03' — or { start, end } of them under range, like the native <input type="month">:

<c-date-picker v-model="billing" label="Billing month" type="month" />

The format is the format with its day left out, so one app default serves both kinds of field: dd.MM.yyyy shows months as MM.yyyy, yyyy-MM-dd as yyyy-MM. A format with no day, such as MM/yyyy, is used as given. Typing is as lenient as for dates: 3.2026 and 032026 both commit as 03.2026. A full date bound as the value is shown as its month and emits nothing; the next pick or commit emits the month.

The panel asks for the month first, then the year. It opens on the twelve months under a "Month" label, with the selected month marked and focused. Picking one collapses it to a summary row and the years unroll beneath it, focused on the selected year — else this year, else the nearest year that can be picked. Picking a year commits the month and closes the panel; pressing the summary row goes back to the months. Both lists take the arrows, Home and End, and Enter or Space to pick.

Under range the steps run twice, labelled "Start month", "Start year", "End month" and "End year". The finished start shows as a summary row and is only pending, as in the day grid: nothing is emitted until the end's year completes the range, a range picked backwards is swapped, and dismissing the panel discards the start.

min and max may be months or full dates; a full date counts by its month, so min="2026-03-15" still allows March. A month is disabled only when every one of its days is — by min and max, disabled-dates or is-date-disabled — so a "no weekends" predicate disables no month, and a span covering all of July disables July. In the month list a month is disabled when no allowed year takes it; in the year list a year is disabled when the picked month is disabled in it, so no pick leads to an empty list. The predicate is asked about each day until one is enabled, so in most months it runs once; one that disables nearly every day is asked many times when the months open.

change:month names the displayed month of the day grid, so it is never fired in month mode.

Today

show-today adds a Today button under the calendar. Pressing it does what pressing today in the grid would: it commits today and closes the panel. Under range the first press makes today the pending start and moves focus onto it in the grid; a press while a start is pending completes the range. Under type="month" the button reads "This month" and picks the current month, its month and year at once.

<c-date-picker v-model="due" label="Due date" show-today />

The button is disabled, never hidden, while today cannot be picked: outside min and max, in disabled-dates, or ruled out by is-date-disabled. It goes by the rules assigned at that moment, as typed text does, so when disabled-dates is loaded per displayed month, keep today's dates in the list or express the rule as is-date-disabled. Leave the button off where today is never the answer, such as a birthdate, or turn it on app-wide with applyDefaults({ 'c-date-picker': { showToday: true } }).

Texts

Month and weekday names and each day's accessible name come from texts when given, then from the browser's Intl data for the page's lang, then from the English built-ins — so a page with <html lang="fi"> gets Finnish names without any configuration. The labels of the buttons and the range inputs are English unless texts replaces them. Weekday arrays are indexed like Date.getDay(), Sunday first. Set them app-wide with applyDefaults({ 'c-date-picker': { texts } }).

Narrow viewports

On a viewport narrower than 760px the calendar opens as a fullscreen panel: a heading row with the field's label and a close button above the calendar, and a Done button below it. There a pick only selects: the day, the range or the month waits in the panel, and nothing is emitted until Done commits it and closes the panel. The close button and Escape close the panel without a change, discarding what was picked, and so does the window growing past 760px while it is open.

The Today button selects today the same way. Enter on a day picks it and presses Done at once. Under range Done stays disabled until the second pick completes the range, and under type="month" the panel stays on the year step, the year checked, until Done. Pressing Done before picking anything closes the panel and changes nothing. The field stays typeable at every width.

Native date input

c-text-field type="date" remains the browser's own date input — no custom calendar, the browser's format, and no ranges or disabled dates. Reach for c-date-picker when the format, the calendar's look or those features matter. c-text-field has no month type: for a year and a month, use type="month" here.

c-time-picker is the same typeable field for times of day.

Examples

Basic
Vue React Angular TypeScript
<template>
  <div>
    <c-date-picker
      v-model="date"
      hint="Type a date or open the calendar"
      label="Start date"
      clearable
    />

    <p>Value: {{ date ?? 'null' }}</p>
  </div>
</template>

<script setup lang="ts">
import { ref } from 'vue';

const date = ref<null | string>(null);
</script>
Disabled dates
Vue React Angular TypeScript
<template>
  <div>
    <c-date-picker
      v-model="date"
      :disabled-dates
      :is-date-disabled="isWeekend"
      :min="today"
      hint="Weekdays from today, except Christmas week"
      label="Appointment"
    />

    <p>Value: {{ date ?? 'null' }}</p>
  </div>
</template>

<script setup lang="ts">
import type { CDatePickerDisabledDate } from '@cscfi/csc-ui';

import { ref } from 'vue';

// No weekends, no Christmas week, nothing before today.
const isWeekend = (iso: string) => [0, 6].includes(new Date(iso).getUTCDay());

const today = new Date().toISOString().slice(0, 10);

const year = today.slice(0, 4);

const disabledDates: CDatePickerDisabledDate[] = [
  { end: `${year}-12-31`, start: `${year}-12-24` },
];

const date = ref<null | string>(null);
</script>
Format and week start
Vue React Angular TypeScript
<template>
  <div>
    <c-date-picker
      v-model="date"
      :first-day-of-week="0"
      format="M/d/yyyy"
      label="Due date"
      show-week-numbers
    />

    <p>Value: {{ date ?? 'null' }}</p>
  </div>
</template>

<script setup lang="ts">
import { ref } from 'vue';

const date = ref<null | string>('2026-09-28');
</script>
Lazy month
Vue React Angular TypeScript
<template>
  <div>
    <!-- `change:month` names the displayed month — on open too — so the
         booked days load one month at a time. -->
    <c-date-picker
      v-model="date"
      :disabled-dates="booked"
      hint="Booked days load as you browse"
      label="Booking"
      @change:month="onMonth"
    />

    <p>Value: {{ date ?? 'null' }}</p>
  </div>
</template>

<script setup lang="ts">
import { ref } from 'vue';

// A simulated booking API: the fully booked days of one month.
const fetchBooked = (month: string): Promise<string[]> =>
  new Promise((resolve) =>
    setTimeout(
      () =>
        resolve(
          ['03', '04', '11', '17', '18', '25'].map((d) => `${month}-${d}`),
        ),
      300,
    ),
  );

const booked = ref<string[]>([]);

const date = ref<null | string>(null);

const onMonth = async (event: CustomEvent<string>) => {
  booked.value = await fetchBooked(event.detail);
};
</script>
Month
Vue React Angular TypeScript
<template>
  <div>
    <c-date-picker
      v-model="billing"
      hint="Type a month or open the month list"
      label="Billing month"
      type="month"
      clearable
    />

    <p>Value: {{ billing ?? 'null' }}</p>

    <c-date-picker
      v-model="period"
      label="Reporting period"
      type="month"
      clearable
      range
    />

    <p>Value: {{ period ? `${period.start} – ${period.end}` : 'null' }}</p>
  </div>
</template>

<script setup lang="ts">
import type { CDatePickerRange } from '@cscfi/csc-ui';

import { ref } from 'vue';

const billing = ref<null | string>(null);

const period = ref<CDatePickerRange | null>(null);
</script>
Range
Vue React Angular TypeScript
<template>
  <div>
    <c-date-picker v-model="leave" label="Leave" clearable range />

    <p>Value: {{ leave ? `${leave.start} – ${leave.end}` : 'null' }}</p>
  </div>
</template>

<script setup lang="ts">
import type { CDatePickerRange } from '@cscfi/csc-ui';

import { ref } from 'vue';

const leave = ref<CDatePickerRange | null>(null);
</script>
Texts
Vue React Angular TypeScript
<template>
  <div>
    <c-date-picker
      v-model="period"
      :texts
      hint="Kirjoita päivämäärät tai valitse kalenterista"
      label="Lomajakso"
      range
      show-week-numbers
    />

    <p>Value: {{ period ? `${period.start} – ${period.end}` : 'null' }}</p>
  </div>
</template>

<script setup lang="ts">
import type { CDatePickerRange, CDatePickerTexts } from '@cscfi/csc-ui';

import { ref } from 'vue';

const months = [
  'tammikuu',
  'helmikuu',
  'maaliskuu',
  'huhtikuu',
  'toukokuu',
  'kesäkuu',
  'heinäkuu',
  'elokuu',
  'syyskuu',
  'lokakuu',
  'marraskuu',
  'joulukuu',
];

const weekdays = [
  'sunnuntai',
  'maanantai',
  'tiistai',
  'keskiviikko',
  'torstai',
  'perjantai',
  'lauantai',
];

// Every text, so none falls back to Intl for the page's lang or to English;
// the month and year step labels show under type="month", Today under
// show-today.
const texts: CDatePickerTexts = {
  chooseDate: 'Valitse päivä',
  clearSelection: 'Tyhjennä',
  closePanel: 'Sulje',
  // A day's name, its month in the partitive: keskiviikko 14. helmikuuta 2001.
  date: (iso) => {
    const [y, m, d] = iso.split('-').map(Number);

    const weekday = weekdays[new Date(Date.UTC(y, m - 1, d)).getUTCDay()];

    return `${weekday} ${d}. ${months[m - 1]}ta ${y}`;
  },
  done: 'Valmis',
  end: 'Loppupäivä',
  endMonth: 'Loppukuukausi',
  endYear: 'Loppuvuosi',
  month: 'Kuukausi',
  months,
  monthsShort: [
    'tammi',
    'helmi',
    'maalis',
    'huhti',
    'touko',
    'kesä',
    'heinä',
    'elo',
    'syys',
    'loka',
    'marras',
    'joulu',
  ],
  nextMonth: 'Seuraava kuukausi',
  nextYear: 'Seuraava vuosi',
  openCalendar: 'Avaa kalenteri',
  pendingStart: (date) => `Alkupäivä ${date} valittu. Valitse loppupäivä.`,
  previousMonth: 'Edellinen kuukausi',
  previousYear: 'Edellinen vuosi',
  selectMonth: 'Valitse kuukausi',
  selectYear: 'Valitse vuosi',
  start: 'Alkupäivä',
  startMonth: 'Alkukuukausi',
  startYear: 'Alkuvuosi',
  thisMonth: 'Tämä kuukausi',
  today: 'Tänään',
  unavailable: 'ei valittavissa',
  weekdays,
  weekdaysShort: ['su', 'ma', 'ti', 'ke', 'to', 'pe', 'la'],
  weekNumber: 'Viikko',
  year: 'Vuosi',
};

const period = ref<CDatePickerRange | null>(null);
</script>
Today
Vue React Angular TypeScript
<template>
  <div>
    <c-date-picker
      v-model="date"
      hint="Today under the calendar sets the field back to today"
      label="Due date"
      show-today
    />

    <p>Value: {{ date ?? 'null' }}</p>
  </div>
</template>

<script setup lang="ts">
import { ref } from 'vue';

const date = ref<null | string>('2025-03-14');
</script>

API reference

<c-date-picker>

A date field that takes a typed date, or opens a calendar panel for picking one, or a start and end date under `range`.

Properties

PropertyAttributeTypeDefaultDescription
clearableclearablebooleanfalse Make the value clearable
disableddisabledbooleanfalse Disable the field
disabledDates—CDatePickerDisabledDate[]() => [] Dates that cannot be picked: ISO dates and inclusive `{ start, end }` spans. Arrays have no attribute form — bind as a DOM property
errorMessageerror-messagestring'' Error message shown in place of the hint while the field is invalid
firstDayOfWeekfirst-day-of-weekCDatePickerWeekday1 app default First day of the week in the calendar, numbered like `Date.getDay()`: 0 = Sunday, 1 = Monday … 6 = Saturday
formatformatstring'dd.MM.yyyy' app default How dates are shown and read from typing: a pattern of the tokens `d`, `dd`, `M`, `MM` and `yyyy` with any separators, e.g. `yyyy-MM-dd`
hideMessagehide-messagebooleanfalse app default Hide the message line — the hint and error messages under the field — and the room it keeps.
hinthintstring'' Hint text for the field
invalidinvalidbooleanfalse Show the control as invalid: its `error-message`, when set, replaces the hint, and the control is marked `aria-invalid`.
isDateDisabled—(iso: string) => boolean— Predicate for dates that cannot be picked (weekends, say); receives an ISO date. Functions have no attribute form — bind as a DOM property
labellabelstring'' Element label
labelOnToplabel-on-topbooleanfalse app default Label on top of the field
maxmaxstring'' The latest date that can be picked or typed, as an ISO date; also bounds the calendar's navigation
minminstring'' The earliest date that can be picked or typed, as an ISO date; also bounds the calendar's navigation
namenamestring'' The name the date submits under in a native `<form>`, as its ISO text; a `range` as one ISO 8601 interval, `start/end`
placeholderplaceholderstring'' Placeholder of the input; the `format` pattern when empty
rangerangebooleanfalse Pick a range: the value becomes `{ start, end }` and the field holds two inputs
requiredrequiredbooleanfalse Set the field as required
shadowshadowbooleanfalse app default Shadow variant
showTodayshow-todaybooleanfalse app default Show a Today button under the calendar that picks today ("This month" under `type="month"`)
showWeekNumbersshow-week-numbersbooleanfalse app default Show ISO 8601 week numbers beside the calendar rows (meaningful with a Monday week start)
sizesizeCFieldSize'default' app default Field height: the 52px default (the shared control height) or the 36px `small` box
texts—CDatePickerTexts{} app default UI text overrides (i18n), merged over the names `Intl` gives for the page's `lang` and the English defaults. Objects have no attribute form — bind as a DOM property
typetypeCDatePickerType'date' What the field picks: a calendar date, or a year and a month (`'YYYY-MM'`)
valuevalueCDatePickerValuenull The date as an ISO `YYYY-MM-DD` string (an ISO `YYYY-MM` month under `type="month"`), or `{ start, end }` under `range`; `null` when empty
hideDetails deprecated hide-detailsbooleanfalse app default Deprecated. Use `hide-message`. Hide the hint and error messages

app default marks a prop you can set for every instance at once with applyDefaults() — an explicit attribute or property on an instance still wins.

Events

EventDetailDescription
changeCDatePickerValueFired when the value changes — a day or range is picked, typed text is committed, or the field is cleared — carrying the new value: an ISO date, `{ start, end }` under `range`, or `null`.
change:monthstringFired with the displayed month as `YYYY-MM` whenever it changes, and when the panel opens — the signal to load that month's `disabled-dates`.
change:textCDatePickerTextFired on every commit of typed text (Enter or leaving the input) with the text as typed — `{ start, end }` under `range`. Read `badInput` to tell whether it named a date that can be picked.
inputvoidNative bubbling input event dispatched alongside every value change so a plain `v-model` stays in sync. Carries no detail.
update:valueCDatePickerValueFired alongside `change` with the same detail — the `v-model` contract.

Methods

MethodSignatureDescription
badInput: boolean (read-only)Whether the committed text names no date that can be picked — the value is then `null` (CONTEXT.md "Bad input").
focus(options?: FocusOptions): voidFocus its input (the start input under `range`), as `focus()` does on a native control: the element renders no box of its own to take it.

CSS parts

Style from outside with c-date-picker::part(name) — parts are the library's only styling customization API.

PartDescription
inputThe text input; under `range` both the start and the end input
separatorThe dash between the start and end inputs under `range`
panelThe top-layer popover container anchored below the field
cardThe dialog surface inside the panel holding the header and the calendar body
heading-rowThe top row of the fullscreen panel (narrow viewports): the field label as heading and the close button
headingThe field label naming the fullscreen panel
closeThe close button of the fullscreen panel
headerThe row of month and year controls above the calendar body
previous-monthThe arrow to the previous month
next-monthThe arrow to the next month
month-buttonThe button showing the displayed month that opens the month list
previous-yearThe arrow to the same month a year earlier
next-yearThe arrow to the same month a year later
year-buttonThe button showing the displayed year that opens the year list
gridThe day grid of the displayed month
weekdayA weekday column head in the grid
week-numberAn ISO week number beside a grid row (`show-week-numbers`)
cellOne day's cell in the grid
dayThe circle showing a day's number inside its cell
range-bandThe strip joining a range's days behind their circles
listThe month or year list swapped in for the grid
optionOne month or year in the list
step-labelThe label above the current list under `type="month"`: month or year, and under `range` start or end
step-summaryA finished step under `type="month"`, its label and pick; pressing it returns to that step
actionsThe row under the calendar body holding the Today button (`show-today`) and, in the fullscreen panel, the Done button
todayThe Today button: picks today, or the current month under `type="month"`
doneThe Done button of the fullscreen panel (narrow viewports): commits what the panel holds and closes
messageThe hint / error message area below the field (always reserved unless `hide-message`)

Custom states

Select on the host's live state with c-date-picker:state(name) — combine with ::part() for per-state styling, e.g. c-date-picker:state(checked)::part(indicator) targets the indicator only while checked.

StateDescription
bad-inputPresent while committed text names no date that can be picked

Types

Importable from the package root: import type { … } from '@cscfi/csc-ui'

CDatePickerDisabledDate

One entry of `disabled-dates`: an ISO date, or an inclusive `{ start, end }` span of them.

export type CDatePickerDisabledDate = { end: string; start: string } | string;
CDatePickerRange

A date range: ISO `YYYY-MM-DD` ends (`YYYY-MM` under `type="month"`), either of which may be `null` while only one is typed.

export interface CDatePickerRange {
  /** The last day of the range, inclusive. */
  end: null | string;

  /** The first day of the range. */
  start: null | string;
}
CDatePickerText

The text committed from the field, as typed: a string, or both ends' texts under `range`.

export type CDatePickerText = { end: string; start: string } | string;
CDatePickerTexts

UI texts of `c-date-picker`, merged key by key over the names `Intl` gives for the page's `lang` and the English defaults. Weekday arrays are indexed like `Date.getDay()`: Sunday first.

export interface CDatePickerTexts {
  /** Accessible name of the dialog when the field has no label. */
  chooseDate?: string;

  /** Accessible label of the clear button. */
  clearSelection?: string;

  /** Accessible label of the close button in the fullscreen panel (narrow viewports). */
  closePanel?: string;

  /** A day's accessible name in the grid; receives the ISO date. */
  date?: (iso: string) => string;

  /** Label of the Done button in the fullscreen panel (narrow viewports). */
  done?: string;

  /** Accessible name of the end input under `range`. */
  end?: string;

  /** Label of the end's month step under `type="month"` and `range`; also the end input's name there. */
  endMonth?: string;

  /** Label of the end's year step under `type="month"` and `range`. */
  endYear?: string;

  /** Label of the month step under `type="month"`. */
  month?: string;

  /** Twelve month names, January first. */
  months?: string[];

  /** Twelve short month names, January first — shown on the month button. */
  monthsShort?: string[];

  /** Accessible label of the next-month arrow. */
  nextMonth?: string;

  /** Accessible label of the next-year arrow. */
  nextYear?: string;

  /** Accessible label of the calendar button. */
  openCalendar?: string;

  /** Announcement once a range's first day is picked; receives that day's name. */
  pendingStart?: (date: string) => string;

  /** Accessible label of the previous-month arrow. */
  previousMonth?: string;

  /** Accessible label of the previous-year arrow. */
  previousYear?: string;

  /** Accessible label of the month button and the month list. */
  selectMonth?: string;

  /** Accessible label of the year button and the year list. */
  selectYear?: string;

  /** Accessible name of the start input under `range`. */
  start?: string;

  /** Label of the start's month step under `type="month"` and `range`; also the start input's name there. */
  startMonth?: string;

  /** Label of the start's year step under `type="month"` and `range`. */
  startYear?: string;

  /** Label of the Today button under `type="month"`. */
  thisMonth?: string;

  /** Label of the Today button (`show-today`). */
  today?: string;

  /** Appended to the accessible name of a day that cannot be picked. */
  unavailable?: string;

  /** Seven weekday names, Sunday first. */
  weekdays?: string[];

  /** Seven short weekday names, Sunday first — the grid's column heads. */
  weekdaysShort?: string[];

  /** Accessible name of the week-number column. */
  weekNumber?: string;

  /** Label of the year step under `type="month"`. */
  year?: string;
}
CDatePickerType

What `c-date-picker` picks: a calendar date, or a year and a month (ADR-0063).

export type CDatePickerType = 'date' | 'month';
CDatePickerValue

Value of `c-date-picker`: an ISO `YYYY-MM-DD` string (`YYYY-MM` under `type="month"`), a under `range`, or `null` when empty.

export type CDatePickerValue = CDatePickerRange | null | string;
CDatePickerWeekday

A day of the week numbered like `Date.getDay()`: 0 = Sunday … 6 = Saturday.

export type CDatePickerWeekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
CFieldSize shared

Field height of the form controls built on `c-input`. `default` is the 44px field; `small` is the 36px field. Owned here because the value passes from the wrapping control (`c-select`) into `c-input`.

export type CFieldSize = 'default' | 'small';