@koobiq/components 16.0.0-beta.1

package/code-block/code-block.scss

@@ -0,0 +1,128 @@
+@use 'sass:meta';
+@use 'sass:map';
+@use '../core/styles/tokens';
+
+$tokens: meta.module-variables(tokens) !default;
+
+
+/* stylelint-disable no-descending-specificity */
+.kbq-code-block {
+    display: block;
+    position: relative;
+
+    box-sizing: border-box;
+
+    hyphens: none;
+    -ms-hyphens: none;
+    -moz-hyphens: none;
+    -webkit-hyphens: none;
+
+    border-width: 1px;
+    border-style: solid;
+    border-radius: map.get($tokens, code-block-size-border-radius);
+
+    &:not(.kbq-code-block_no-header) .kbq-tab-group:after {
+        content: "";
+
+        position: absolute;
+        top: 39px;
+        left: 0;
+        right: 0;
+
+        height: 1px;
+    }
+
+    .kbq-tab-header {
+        // 4 buttons + margin
+        margin-right: calc(32 * 4) + 24px;
+    }
+
+    &.kbq-code-block_hide-line-numbers .hljs-ln-line.hljs-ln-numbers {
+        display: none;
+    }
+
+    &.kbq-code-block_single-file {
+        .kbq-tab-label {
+            &:before {
+                content: none;
+            }
+
+            &:hover {
+                background: transparent !important;
+            }
+        }
+    }
+
+    &.kbq-code-block_no-header {
+        .kbq-code-block__code {
+            position: relative;
+        }
+
+        .kbq-tab-header {
+            display: none;
+        }
+    }
+
+    pre {
+        margin: 0;
+    }
+
+    .kbq-tab-body__wrapper {
+        flex-direction: column;
+        position: unset;
+    }
+
+    .kbq-tab-body.kbq-tab-body__active {
+        position: unset;
+    }
+}
+
+.kbq-code-block__code {
+    overflow-y: hidden;
+
+    &.kbq-code-block__code_view-all {
+        max-height: unset;
+        overflow-y: unset;
+    }
+
+    &.kbq-code-block__code_soft-wrap {
+        white-space: pre-wrap
+    }
+
+    > code {
+        padding: map.get($tokens, code-block-size-padding) !important;
+    }
+
+    .hljs-ln {
+        border-collapse: unset;
+
+        .hljs {
+            padding: 0;
+        }
+    }
+
+    .hljs-ln-numbers {
+        border-right-width: map.get($tokens, code-block-size-line-numbers-border-width);
+        padding: map.get($tokens, code-block-size-line-numbers-padding);
+
+        vertical-align: baseline;
+        text-align: right;
+    }
+
+    .hljs-ln-n:before {
+        white-space: nowrap;
+    }
+}
+
+.kbq-code-block__show-more {
+    overflow: hidden;
+
+    width: 100%;
+
+    border-top-style: solid !important;
+    border-top-width: 1px !important;
+
+    border-top-left-radius: 0 !important;
+    border-top-right-radius: 0 !important;
+}
+/* stylelint-enable no-descending-specificity */

package/code-block/code-block.types.d.ts

@@ -0,0 +1,16 @@
+export interface KbqCodeBlockConfiguration {
+    softWrapOnTooltip: string;
+    softWrapOffTooltip: string;
+    downloadTooltip: string;
+    copiedTooltip: string;
+    copyTooltip: string;
+    viewAllText: string;
+    viewLessText: string;
+    openExternalSystemTooltip: string;
+}
+export interface KbqCodeFile {
+    filename: string;
+    content: string;
+    language: string;
+    link?: string;
+}

package/code-block/index.d.ts

@@ -0,0 +1 @@
+export * from './public-api';

package/code-block/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './code-block.module';
+export * from './code-block.types';
+export * from './code-block.component';

package/core/_index.scss

@@ -0,0 +1 @@
+@forward 'styles/core';

package/core/animation/animation.d.ts

@@ -0,0 +1,6 @@
+export declare enum AnimationCurves {
+    StandardCurve = "cubic-bezier(0.4,0.0,0.2,1)",
+    DecelerationCurve = "cubic-bezier(0.0,0.0,0.2,1)",
+    AccelerationCurve = "cubic-bezier(0.4,0.0,1,1)",
+    SharpCurve = "cubic-bezier(0.4,0.0,0.6,1)"
+}

package/core/animation/fade-animations.d.ts

@@ -0,0 +1,2 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+export declare const fadeAnimation: AnimationTriggerMetadata;

package/core/animation/index.d.ts

@@ -0,0 +1,3 @@
+export { fadeAnimation } from './fade-animations';
+export * from './animation';
+export { mcSelectAnimations } from './select-animations';

package/core/animation/select-animations.d.ts

@@ -0,0 +1,12 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+/**
+ * The following are all the animations for the kbq-select component, with each
+ * const containing the metadata for one animation.
+ *
+ */
+export declare const mcSelectAnimations: {
+    readonly transformPanel: AnimationTriggerMetadata;
+    readonly fadeInContent: AnimationTriggerMetadata;
+};
+export declare const transformPanel: AnimationTriggerMetadata;
+export declare const fadeInContent: AnimationTriggerMetadata;

package/core/common-behaviors/color.d.ts

@@ -0,0 +1,33 @@
+import { ElementRef } from '@angular/core';
+import { AbstractConstructor, Constructor } from './constructor';
+export interface CanColor {
+    color: KbqComponentColors | ThemePalette;
+}
+/** @docs-private */
+export type CanColorCtor = Constructor<CanColor> & AbstractConstructor<CanColor>;
+export interface HasElementRef {
+    elementRef: ElementRef;
+}
+export declare enum ThemePalette {
+    Primary = "primary",
+    Secondary = "secondary",
+    Error = "error",
+    Info = "info",
+    Warning = "warning",
+    Success = "success",
+    Default = "secondary",
+    Empty = ""
+}
+export declare enum KbqComponentColors {
+    Theme = "theme",
+    ThemeFade = "theme-fade",
+    Contrast = "contrast",
+    ContrastFade = "contrast-fade",
+    Error = "error",
+    Warning = "warning",
+    Success = "success",
+    Default = "contrast",
+    Empty = ""
+}
+/** Mixin to augment a directive with a `color` property. */
+export declare function mixinColor<T extends AbstractConstructor<HasElementRef>>(base: T, defaultColor?: KbqComponentColors | ThemePalette): CanColorCtor & T;

package/core/common-behaviors/common-module.d.ts

@@ -0,0 +1,25 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+export declare const KBQ_SANITY_CHECKS: InjectionToken<boolean>;
+export declare function mcSanityChecksFactory(): boolean;
+/**
+ * Module that captures anything that should be loaded and/or run for *all* Mosaic
+ * components. This includes Bidi, etc.
+ *
+ * This module should be imported to each top-level component module (e.g., KbqTabsModule).
+ */
+export declare class KbqCommonModule {
+    private _sanityChecksEnabled;
+    private hasDoneGlobalChecks;
+    private _document;
+    private _window;
+    constructor(_sanityChecksEnabled: boolean);
+    private areChecksEnabled;
+    private isTestEnv;
+    private checkDoctypeIsDefined;
+    private checkThemeIsPresent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqCommonModule, [{ optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqCommonModule, never, [typeof i1.BidiModule], [typeof i1.BidiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqCommonModule>;
+}

package/core/common-behaviors/constructor.d.ts

@@ -0,0 +1,9 @@
+/** @docs-private */
+export type Constructor<T> = new (...args: any[]) => T;
+/**
+ * This is a permissive type for abstract class constructors.
+ * @docs-private
+ */
+export type AbstractConstructor<T> = Function & {
+    prototype: T;
+};

package/core/common-behaviors/disabled.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConstructor, Constructor } from './constructor';
+export interface CanDisable {
+    disabled: boolean;
+}
+/** @docs-private */
+export type CanDisableCtor = Constructor<CanDisable> & AbstractConstructor<CanDisable>;
+/** Mixin to augment a directive with a `disabled` property. */
+export declare function mixinDisabled<T extends AbstractConstructor<{}>>(base: T): CanDisableCtor & T;

package/core/common-behaviors/error-state.d.ts

@@ -0,0 +1,28 @@
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { ErrorStateMatcher } from '../error/error-options';
+import { AbstractConstructor, Constructor } from './constructor';
+/** @docs-private */
+export interface CanUpdateErrorState {
+    /** Whether the component is in an error state. */
+    errorState: boolean;
+    /** An object used to control the error state of the component. */
+    errorStateMatcher: ErrorStateMatcher;
+    /** Updates the error state based on the provided error state matcher. */
+    updateErrorState(): void;
+}
+/** @docs-private */
+export type CanUpdateErrorStateCtor = Constructor<CanUpdateErrorState>;
+/** @docs-private */
+export interface HasErrorState {
+    parentFormGroup: FormGroupDirective;
+    parentForm: NgForm;
+    defaultErrorStateMatcher: ErrorStateMatcher;
+    ngControl: NgControl;
+    stateChanges: Subject<void>;
+}
+/**
+ * Mixin to augment a directive with updateErrorState method.
+ * For component with `errorState` and need to update `errorState`.
+ */
+export declare function mixinErrorState<T extends AbstractConstructor<HasErrorState>>(base: T): CanUpdateErrorStateCtor & T;

package/core/common-behaviors/index.d.ts

@@ -0,0 +1,5 @@
+export { KbqCommonModule, KBQ_SANITY_CHECKS } from './common-module';
+export { CanDisable, CanDisableCtor, mixinDisabled } from './disabled';
+export { CanColor, CanColorCtor, mixinColor, ThemePalette, KbqComponentColors } from './color';
+export { HasTabIndex, HasTabIndexCtor, mixinTabIndex } from './tabindex';
+export { CanUpdateErrorStateCtor, CanUpdateErrorState, mixinErrorState } from './error-state';

package/core/common-behaviors/tabindex.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConstructor, Constructor } from './constructor';
+import { CanDisable } from './disabled';
+export interface HasTabIndex {
+    tabIndex: number;
+}
+export type HasTabIndexCtor = Constructor<HasTabIndex> & AbstractConstructor<HasTabIndex>;
+/** Mixin to augment a directive with a `tabIndex` property. */
+export declare function mixinTabIndex<T extends AbstractConstructor<CanDisable>>(base: T, defaultTabIndex?: number): HasTabIndexCtor & T;

package/core/datetime/date-adapter.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken } from '@angular/core';
+import { DateAdapter as BaseDateAdapter } from '@mosaic-design/date-adapter';
+import { BehaviorSubject, Observable } from 'rxjs';
+/** InjectionToken for datepicker that can be used to override default locale code. */
+export declare const KBQ_DATE_LOCALE: InjectionToken<string>;
+/** @docs-private */
+export declare function KBQ_DATE_LOCALE_FACTORY(): string;
+export declare abstract class DateAdapter<D> extends BaseDateAdapter<D> {
+    /** A stream that emits when the locale changes. */
+    abstract get localeChanges(): Observable<any>;
+    protected abstract _localeChanges: BehaviorSubject<string>;
+}

package/core/datetime/date-formats.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+import { DateFormats } from '@mosaic-design/date-adapter';
+export declare const KBQ_DATE_FORMATS: InjectionToken<DateFormats>;
+export type KbqDateFormats = DateFormats;

package/core/datetime/index.d.ts

@@ -0,0 +1,2 @@
+export * from './date-formats';
+export * from './date-adapter';

package/core/error/error-options.d.ts

@@ -0,0 +1,14 @@
+import { FormGroupDirective, NgForm, UntypedFormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+/** Error state matcher that matches when a control is invalid and dirty. */
+export declare class ShowOnDirtyErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowOnDirtyErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowOnDirtyErrorStateMatcher>;
+}
+/** Provider that defines how form controls behave with regards to displaying error messages. */
+export declare class ErrorStateMatcher {
+    isErrorState(control: UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorStateMatcher>;
+}

package/core/form-field/form-field-ref.d.ts

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+export interface KbqFormFieldRef {
+    control: any;
+    shouldForward(str: string): boolean;
+}
+/**
+ * Injection token that can be used to inject an instances of `KbqFormField`. It serves
+ * as alternative token to the actual `KbqFormField` class which would cause unnecessary
+ * retention of the `KbqFormField` class and its component metadata.
+ */
+export declare const KBQ_FORM_FIELD_REF: InjectionToken<KbqFormFieldRef>;

package/core/form-field/index.d.ts

@@ -0,0 +1 @@
+export * from './form-field-ref';

package/core/formatters/date/formatter.d.ts

@@ -0,0 +1,9 @@
+import { DateAdapter } from '@mosaic-design/date-adapter';
+import { DateFormatter as BaseDateFormatter } from '@mosaic-design/date-formatter';
+import * as i0 from "@angular/core";
+export declare class DateFormatter<D> extends BaseDateFormatter<D> {
+    readonly adapter: DateAdapter<D>;
+    constructor(adapter: DateAdapter<D>, locale: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatter<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateFormatter<any>>;
+}

package/core/formatters/date/formatter.pipe.d.ts

@@ -0,0 +1,109 @@
+import { PipeTransform } from '@angular/core';
+import { DateTimeOptions } from '@mosaic-design/date-formatter';
+import { DateAdapter } from '../../datetime';
+import { DateFormatter } from './formatter';
+import * as i0 from "@angular/core";
+export declare class AbsoluteDateFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform(value: D | string, currYear?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbsoluteDateFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AbsoluteDateFormatterPipe<any>, "absoluteLongDate", false>;
+}
+export declare class AbsoluteDateTimeFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform(value: D | string, options?: DateTimeOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbsoluteDateTimeFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AbsoluteDateTimeFormatterPipe<any>, "absoluteLongDateTime", false>;
+}
+export declare class AbsoluteDateShortFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform(value: D | string, currYear?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbsoluteDateShortFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AbsoluteDateShortFormatterPipe<any>, "absoluteShortDate", false>;
+}
+export declare class AbsoluteShortDateTimeFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform(value: D | string, options?: DateTimeOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbsoluteShortDateTimeFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AbsoluteShortDateTimeFormatterPipe<any>, "absoluteShortDateTime", false>;
+}
+export declare class RelativeDateFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform(value: D | string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelativeDateFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RelativeDateFormatterPipe<any>, "relativeLongDate", false>;
+}
+export declare class RelativeDateTimeFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform(value: D | string, options?: DateTimeOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelativeDateTimeFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RelativeDateTimeFormatterPipe<any>, "relativeLongDateTime", false>;
+}
+export declare class RelativeShortDateFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform(value: D | string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelativeShortDateFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RelativeShortDateFormatterPipe<any>, "relativeShortDate", false>;
+}
+export declare class RelativeShortDateTimeFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform(value: D | string, options?: DateTimeOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RelativeShortDateTimeFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RelativeShortDateTimeFormatterPipe<any>, "relativeShortDateTime", false>;
+}
+export declare class RangeDateFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform([value1, value2]: D[] | string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeDateFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangeDateFormatterPipe<any>, "rangeLongDate", false>;
+}
+export declare class RangeShortDateFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform([value1, value2]: D[] | string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeShortDateFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangeShortDateFormatterPipe<any>, "rangeShortDate", false>;
+}
+export declare class RangeDateTimeFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform([value1, value2]: D[] | string[], options?: DateTimeOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeDateTimeFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangeDateTimeFormatterPipe<any>, "rangeLongDateTime", false>;
+}
+export declare class RangeMiddleDateTimeFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform([value1, value2]: D[] | string[], options?: DateTimeOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeMiddleDateTimeFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangeMiddleDateTimeFormatterPipe<any>, "rangeMiddleDateTime", false>;
+}
+export declare class RangeShortDateTimeFormatterPipe<D> implements PipeTransform {
+    private adapter;
+    private formatter;
+    constructor(adapter: DateAdapter<D>, formatter: DateFormatter<D>);
+    transform([value1, value2]: D[] | string[], options?: DateTimeOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeShortDateTimeFormatterPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangeShortDateTimeFormatterPipe<any>, "rangeShortDateTime", false>;
+}

package/core/formatters/index.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./number/formatter";
+import * as i2 from "./date/formatter.pipe";
+export declare class KbqFormattersModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqFormattersModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqFormattersModule, [typeof i1.KbqDecimalPipe, typeof i2.AbsoluteDateFormatterPipe, typeof i2.AbsoluteDateTimeFormatterPipe, typeof i2.AbsoluteDateShortFormatterPipe, typeof i2.AbsoluteShortDateTimeFormatterPipe, typeof i2.RelativeDateFormatterPipe, typeof i2.RelativeDateTimeFormatterPipe, typeof i2.RelativeShortDateFormatterPipe, typeof i2.RelativeShortDateTimeFormatterPipe, typeof i2.RangeDateFormatterPipe, typeof i2.RangeShortDateFormatterPipe, typeof i2.RangeDateTimeFormatterPipe, typeof i2.RangeShortDateTimeFormatterPipe, typeof i2.RangeMiddleDateTimeFormatterPipe], never, [typeof i1.KbqDecimalPipe, typeof i2.AbsoluteDateFormatterPipe, typeof i2.AbsoluteDateTimeFormatterPipe, typeof i2.AbsoluteDateShortFormatterPipe, typeof i2.AbsoluteShortDateTimeFormatterPipe, typeof i2.RelativeDateFormatterPipe, typeof i2.RelativeDateTimeFormatterPipe, typeof i2.RelativeShortDateFormatterPipe, typeof i2.RelativeShortDateTimeFormatterPipe, typeof i2.RangeDateFormatterPipe, typeof i2.RangeShortDateFormatterPipe, typeof i2.RangeDateTimeFormatterPipe, typeof i2.RangeShortDateTimeFormatterPipe, typeof i2.RangeMiddleDateTimeFormatterPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqFormattersModule>;
+}
+export * from './number/formatter';
+export * from './date/formatter';
+export * from './date/formatter.pipe';

package/core/formatters/number/formatter.d.ts

@@ -0,0 +1,37 @@
+import { InjectionToken, PipeTransform } from '@angular/core';
+import { KbqLocaleService } from '../../locales';
+import * as i0 from "@angular/core";
+export declare const KBQ_NUMBER_FORMATTER_OPTIONS: InjectionToken<string>;
+export declare const KBQ_NUMBER_FORMATTER_DEFAULT_OPTIONS: ParsedDigitsInfo;
+export declare const NUMBER_FORMAT_REGEXP: RegExp;
+declare class ParsedDigitsInfo {
+    useGrouping: boolean;
+    minimumIntegerDigits: number;
+    minimumFractionDigits: number;
+    maximumFractionDigits: number;
+}
+export declare class KbqDecimalPipe implements PipeTransform {
+    private id;
+    private localeService;
+    private readonly options;
+    constructor(id: string, localeService: KbqLocaleService, options: ParsedDigitsInfo);
+    /**
+     * @param value The number to be formatted.
+     * @param digitsInfo Decimal representation options, specified by a string
+     * in the following format:<br>
+     * <code>{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}</code>.
+     *   - `minIntegerDigits`: The minimum number of integer digits before the decimal point.
+     * Default is `1`.
+     *   - `minFractionDigits`: The minimum number of digits after the decimal point.
+     * Default is `0`.
+     *   - `maxFractionDigits`: The maximum number of digits after the decimal point.
+     * Default is `3`.
+     * @param locale A locale code for the locale format rules to use.
+     * When not supplied, uses the value of `KBQ_LOCALE_ID`, which is `ru` by default.
+     */
+    transform(value: any, digitsInfo?: string, locale?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDecimalPipe, [{ optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KbqDecimalPipe, "mcNumber", false>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KbqDecimalPipe>;
+}
+export {};

package/core/forms/_forms-theme.scss

@@ -0,0 +1,34 @@
+@use 'sass:meta';
+@use 'sass:map';
+
+@use '../styles/typography/typography-utils' as *;
+@use './forms' as *;
+
+
+@mixin kbq-forms-theme($theme) {
+    @include kbq-form-geometry(map.get($theme, tokens));
+
+    $foreground: map.get($theme, foreground);
+
+    $forms: map.get(map.get($theme, components), forms);
+
+    .kbq-form__label {
+        color: map.get($forms, label);
+    }
+
+    .kbq-form__legend {
+        color: map.get($forms, legend);
+    }
+}
+
+@mixin kbq-forms-typography($config) {
+    $tokens: map.get($config, tokens);
+
+    .kbq-form__label {
+        @include kbq-typography-level-to-styles($config, map.get($tokens, forms-font-default-label));
+    }
+
+    .kbq-form__legend {
+        @include kbq-typography-level-to-styles($config, map.get($tokens, forms-font-default-legend));
+    }
+}