@mhmo91/schmancy 0.8.4 → 0.9.2

package/types/src/directives/typewriter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Typewriter Directive - RxJS-based typing animation
+ *
+ * Creates a smooth typewriter effect with automatic cycling through phrases.
+ * Uses RxJS for precise timing and clean reactive patterns.
+ *
+ * @example
+ * ```ts
+ * // Simple cycling through words
+ * html`<div ${typewriter(['Trustless', 'Permissionless', 'Transparent'])}>
+ *   <span class="typed"></span>
+ * </div>`
+ *
+ * // Custom speeds and pauses
+ * html`<div ${typewriter(['Fast', 'Typing'], { typeSpeed: 50, pauseDuration: 1000 })}>
+ *   <span class="typed"></span>
+ * </div>`
+ *
+ * // One-time typing (no loop)
+ * html`<div ${typewriter(['Hello World'], { loop: false })}>
+ *   <span class="typed"></span>
+ * </div>`
+ * ```
+ */
+import type { ElementPart } from 'lit';
+import { AsyncDirective } from 'lit/async-directive.js';
+export interface TypewriterOptions {
+    typeSpeed?: number;
+    deleteSpeed?: number;
+    pauseDuration?: number;
+    loop?: boolean;
+    selector?: string;
+    cursor?: boolean;
+    finalMessage?: string;
+    sound?: boolean;
+    volume?: number;
+}
+declare class TypewriterDirective extends AsyncDirective {
+    private state;
+    private soundEngine;
+    render(_phrases: string[], _options?: TypewriterOptions): symbol;
+    update(part: ElementPart, [phrases, options]: [string[], TypewriterOptions]): symbol;
+    private startTyping;
+    private getTextNode;
+    private cleanup;
+    disconnected(): void;
+    reconnected(): void;
+}
+export declare const typewriter: (_phrases: string[], _options?: TypewriterOptions) => import("lit-html/directive").DirectiveResult<typeof TypewriterDirective>;
+export {};

package/types/src/discovery/discovery.service.d.ts

@@ -1,4 +1,23 @@
 import { Observable } from 'rxjs';
+/**
+ * Global discovery event names
+ */
+declare const DISCOVER_EVENT = "schmancy-discover";
+declare const DISCOVER_RESPONSE_EVENT = "schmancy-discover-response";
+/**
+ * Discovery request detail
+ */
+interface DiscoverRequest {
+    selector: string;
+    requestId: string;
+}
+/**
+ * Discovery response detail
+ */
+interface DiscoverResponse {
+    requestId: string;
+    element: HTMLElement;
+}
 /**
  * Discover a component in the DOM using the WhereAreYou/HereIAm pattern.
  *
@@ -15,3 +34,56 @@ export declare function discoverComponent<T extends HTMLElement>(componentTag: s
  * @returns Observable that emits the first discovered component or null if none found
  */
 export declare function discoverAnyComponent<T extends HTMLElement>(...componentTags: string[]): Observable<T | null>;
+/**
+ * Universal element discovery - finds ANY element by CSS selector across shadow DOM boundaries.
+ * Uses event-based discovery pattern - no DOM traversal needed.
+ *
+ * How it works:
+ * 1. Broadcasts a discovery request event on window
+ * 2. All $LitElement components receive this event and check their shadow DOM
+ * 3. If a match is found, they respond with the element
+ *
+ * @param selector - CSS selector (e.g., '#my-id', '.my-class', '[data-attr]')
+ * @param timeout - How long to wait for a response in milliseconds (default: 150)
+ * @returns Observable that emits the discovered element or null if not found
+ *
+ * @example
+ * ```typescript
+ * // Find element by ID across shadow boundaries
+ * discoverElement('#app-card-melanie').subscribe(el => {
+ *   if (el) console.log('Found:', el)
+ * })
+ *
+ * // Find element by class
+ * discoverElement('.special-button').subscribe(el => {...})
+ * ```
+ */
+export declare function discoverElement<T extends HTMLElement>(selector: string, timeout?: number): Observable<T | null>;
+/**
+ * Discover multiple elements matching a selector.
+ * Collects all responses within the timeout period.
+ *
+ * @param selector - CSS selector
+ * @param timeout - How long to collect responses (default: 150ms)
+ * @returns Observable that emits array of discovered elements
+ */
+export declare function discoverAllElements<T extends HTMLElement>(selector: string, timeout?: number): Observable<T[]>;
+/**
+ * Smart discovery - automatically detects if input is a CSS selector or component tag.
+ *
+ * @param query - CSS selector (starts with #, ., [) OR component tag name
+ * @param timeout - How long to wait (default: 150ms)
+ * @returns Observable that emits the discovered element or null
+ *
+ * @example
+ * ```typescript
+ * // CSS selector - uses discoverElement
+ * discover('#my-element').subscribe(...)
+ *
+ * // Component tag - uses discoverComponent
+ * discover('schmancy-fancy').subscribe(...)
+ * ```
+ */
+export declare function discover<T extends HTMLElement>(query: string, timeout?: number): Observable<T | null>;
+export { DISCOVER_EVENT, DISCOVER_RESPONSE_EVENT };
+export type { DiscoverRequest, DiscoverResponse };

package/types/src/expand/expand-root.component.d.ts

@@ -0,0 +1,30 @@
+import { nothing } from 'lit';
+import type { TSurfaceColor } from '@schmancy/types';
+import '../surface/surface.js';
+declare const SchmancyExpandRoot_base: import("@mixins/index").Constructor<import("@mixins/index").ISurfaceMixin> & import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+export declare class SchmancyExpandRoot extends SchmancyExpandRoot_base {
+    type: TSurfaceColor;
+    isOpen: boolean;
+    private summaryRect;
+    private _panelRef;
+    private _backdropRef;
+    private _btnRef;
+    private _owner;
+    private _hideIndicator;
+    private _backdrop;
+    /** Called by schmancy-expand before nodes are moved */
+    prepare(rect: DOMRect, owner: Element, hideIndicator?: boolean, backdrop?: boolean): void;
+    /** Called by schmancy-expand after nodes are moved in */
+    triggerOpen(): Promise<void>;
+    /** Animate close, return Promise resolving when done */
+    triggerClose(targetRect: DOMRect): Promise<void>;
+    private _animateOpen;
+    private _animateClose;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-expand-root': SchmancyExpandRoot;
+    }
+}
+export {};

package/types/src/expand/expand.component.d.ts

@@ -0,0 +1,38 @@
+/** Dispatch this event on window to close whichever schmancy-expand is currently open */
+export declare const SCHMANCY_EXPAND_REQUEST_CLOSE = "schmancy-expand-request-close";
+declare const SchmancyExpand_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+export default class SchmancyExpand extends SchmancyExpand_base {
+    summary: string;
+    open: boolean;
+    summaryPadding: string;
+    contentPadding: string;
+    hideIndicator: boolean;
+    indicatorRotate: number;
+    backdrop: boolean;
+    inline: boolean;
+    private _summaryRef;
+    private _contentSlotRef;
+    private _root;
+    private _movedNodes;
+    private _currentIndicatorAnim;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _getOrCreateRoot;
+    /** Close the expand portal, animating back to the summary position. */
+    close(): void;
+    /** Programmatically open the expand portal. */
+    expand(): void;
+    protected updated(changed: Map<PropertyKey, unknown>): void;
+    private _toggle;
+    private _handleSummaryClick;
+    private _expand;
+    _handleClose(): Promise<void>;
+    private _animateIndicator;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-expand': SchmancyExpand;
+    }
+}
+export {};

package/types/src/expand/index.d.ts

@@ -0,0 +1,2 @@
+export * from './expand.component.js';
+export * from './expand-root.component.js';

package/types/src/float/float.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Backward compatibility alias — schmancy-float is now schmancy-window.
+ *
+ * Existing consumers using <schmancy-float> continue to work.
+ * New code should use <schmancy-window> directly.
+ */
+import SchmancyWindow from '../window/window.js';
+export default class SchmancyFloat extends SchmancyWindow {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-float': SchmancyFloat;
+    }
+}

package/types/src/float/index.d.ts

@@ -0,0 +1 @@
+export { default as SchmancyFloat } from './float';

package/types/src/icons/icon.d.ts

@@ -51,12 +51,26 @@ export default class SchmancyIcon extends SchmancyIcon_base {
      * Custom: any CSS size string like '48px', '2rem'
      */
     size: IconSize;
+    /**
+     * Icon name - use this instead of slot content to prevent translation breaking icons.
+     * When set, this takes precedence over slot content.
+     * Example: <schmancy-icon icon="delete"></schmancy-icon>
+     */
+    icon?: string;
     private static readonly tokenSizes;
+    /** Extract pixel value from a custom size string for optical size */
+    private static computeOpticalSize;
     private fill$;
     private weight$;
     private grade$;
     private variant$;
+    private _capturedIcon?;
+    private _observer?;
     connectedCallback(): void;
+    /**
+     * Update captured icon from current text content
+     */
+    private _updateCapturedIcon;
     protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
     protected render(): unknown;
 }

package/types/src/iframe/iframe.d.ts

@@ -0,0 +1,37 @@
+import { PropertyValues } from 'lit';
+declare const SchmancyIframe_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * Renders an HTML fragment inside a sandboxed, auto-sizing iframe.
+ *
+ * @slot - (none)
+ * @fires load — native iframe load event
+ *
+ * @example
+ * ```html
+ * <schmancy-iframe .html=${bodyHtml} .css=${extraStyles}></schmancy-iframe>
+ * ```
+ */
+export default class SchmancyIframe extends SchmancyIframe_base {
+    /** HTML body fragment to render inside the iframe */
+    html: string;
+    /** Additional CSS injected after the base styles (consumer-specific) */
+    css: string;
+    /** Base document CSS (font, spacing, resets). Override for fully custom styling */
+    baseCss: string;
+    /** iframe sandbox attribute */
+    sandbox: string;
+    /** Minimum height in pixels */
+    minHeight: number;
+    private _height;
+    private _srcdoc;
+    protected willUpdate(changed: PropertyValues): void;
+    private buildSrcdoc;
+    private onLoad;
+    protected render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-iframe': SchmancyIframe;
+    }
+}
+export {};

package/types/src/iframe/index.d.ts

@@ -0,0 +1 @@
+export { default as SchmancyIframe } from './iframe';

package/types/src/index.d.ts

@@ -1,4 +1,3 @@
-export * from './animated-text';
 export * from './area';
 export * from './audio';
 export * from './autocomplete';
@@ -12,6 +11,7 @@ export * from './checkbox';
 export * from './chips';
 export * from './code-highlight';
 export * from './components';
+export * from './connectivity';
 export * from './content-drawer';
 export * from './date-range';
 export * from './date-range-inline';
@@ -22,9 +22,13 @@ export * from './directives';
 export * from './discovery';
 export * from './divider';
 export * from './dropdown';
+export * from './expand';
+export * from './float';
+export * from './window';
 export * from './extra';
 export * from './form';
 export * from './icons';
+export * from './iframe';
 export * from './input';
 export * from './json';
 export * from './layout';
@@ -42,6 +46,7 @@ export * from './page';
 export * from './progress';
 export * from './qr-scanner';
 export * from './radio-group';
+export * from './range';
 export * from './rxjs-utils';
 export * from './select';
 export * from './sheet';

package/types/src/input/index.d.ts

@@ -1 +1 @@
-export { default as SchmancyInput, SchmancyInputCompat, type SchmancyInputChangeEvent, type InputSize } from './input';
+export { default as SchmancyInput, SchmancyInputCompat, type SchmancyInputInputEvent, type SchmancyInputChangeEvent, type SchmancyInputEnterEvent, type InputSize, } from './input';

package/types/src/layout/scroll/scroll.d.ts

@@ -63,6 +63,17 @@ declare const SchmancyScroll_base: import("@mixins/index").Constructor<CustomEle
  *   </div>
  * </schmancy-scroll>
  * ```
+ *
+ * @example Programmatic scroll with Lit ref
+ * ```typescript
+ * private scrollRef = createRef<HTMLElement>()
+ *
+ * // In template:
+ * html`<schmancy-scroll ${ref(this.scrollRef)}>...</schmancy-scroll>`
+ *
+ * // Scroll to top (smooth — host has scroll-behavior: smooth):
+ * this.scrollRef.value?.scrollTo({ top: 0 })
+ * ```
  */
 export declare class SchmancyScroll extends SchmancyScroll_base {
     /**

package/types/src/lightbox/lightbox.d.ts

@@ -7,6 +7,7 @@ export declare class SchmancyLightbox extends SchmancyLightbox_base {
     open: boolean;
     private currentIndex;
     private isLoading;
+    private zIndex;
     private readonly swipeThreshold;
     private overlayRef;
     private contentRef;

package/types/src/mailbox/email-recipients.d.ts

@@ -96,9 +96,9 @@ export declare class SchmancyEmailRecipients extends SchmancyEmailRecipients_bas
     private handleBoatStateChange;
     /** Add recipients programmatically */
     addRecipients(emails: string[]): void;
-    /** Show boat */
+    /** Show boat (collapsed) */
     showBoat(): void;
-    /** Hide boat */
+    /** Hide boat (collapse) */
     hideBoat(): void;
     /** Expand boat */
     expandBoat(): void;

package/types/src/mailbox/types.d.ts

@@ -170,7 +170,7 @@ export type EmailComposeEvents = {
 /**
  * Boat state options for recipients panel
  */
-export type BoatState = 'hidden' | 'minimized' | 'expanded';
+export type BoatState = 'collapsed' | 'expanded';
 /**
  * Email preview view modes
  */

package/types/src/navigation-bar/navigation-bar.d.ts

@@ -79,7 +79,24 @@ export declare class SchmancyNavigationBar extends SchmancyNavigationBar_base {
      * Minimum scroll threshold before triggering hide/show
      */
     private readonly SCROLL_THRESHOLD;
+    /**
+     * Media query for mobile detection
+     */
+    private mobileMediaQuery;
+    /**
+     * Subject to track visibility state changes
+     */
+    private visibility$;
+    /**
+     * Check if on mobile viewport
+     */
+    private isMobileViewport;
+    /**
+     * Update bottom offset for schmancy-page/fullHeight consumers
+     */
+    private updateBottomOffset;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     /**
      * Set up RxJS-based scroll listener
      */

package/types/src/notification/notification.d.ts

@@ -1,3 +1,4 @@
+import '../progress/progress';
 export type NotificationType = 'info' | 'success' | 'warning' | 'error';
 declare const SchmancyNotification_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 /**

package/types/src/page/page.d.ts

@@ -3,6 +3,7 @@ declare const SchmancyPage_base: CustomElementConstructor & import("@mixins/inde
 /**
  * Native mobile-like page container.
  * Prevents double-tap zoom, pull-to-refresh, rubber-banding.
+ * Automatically fills remaining viewport height.
  *
  * @element schmancy-page
  *
@@ -20,7 +21,12 @@ export declare class SchmancyPage extends SchmancyPage_base {
     rows: string;
     showScrollbar: boolean;
     noSelect: boolean;
+    private heightDisconnecting$;
+    private calculateHeight;
+    private applyHeight;
+    private setupHeightStream;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     protected render(): import("lit-html").TemplateResult<1>;
 }
 declare global {

package/types/src/range/index.d.ts

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

package/types/src/range/range.d.ts

@@ -0,0 +1,25 @@
+export type SchmancyRangeChangeEvent = CustomEvent<{
+    value: number;
+}>;
+declare const SchmancyRange_base: import("@mixins/index").Constructor<CustomElementConstructor> & import("@mixins/index").Constructor<import("@mixins/index").ITailwindElementMixin> & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
+/**
+ * @element schmancy-range
+ * Range input (numeric slider).
+ * @fires change - Fires on value change with { value: number }
+ */
+export declare class SchmancyRange extends SchmancyRange_base {
+    min: number;
+    max: number;
+    step: number;
+    value: number;
+    label?: string;
+    disabled: boolean;
+    private get progress();
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'schmancy-range': SchmancyRange;
+    }
+}
+export {};

package/types/src/sheet/sheet.d.ts

@@ -1,7 +1,6 @@
 import { SchmancySheetPosition } from './sheet.service';
 declare const SchmancySheet_base: CustomElementConstructor & import("@mixins/index").Constructor<import("lit").LitElement> & import("@mixins/index").Constructor<import("@mixins/index").IBaseMixin>;
 export default class SchmancySheet extends SchmancySheet_base {
-    uid: string;
     open: boolean;
     position: SchmancySheetPosition;
     persist: boolean;

package/types/src/steps/schmancy-steps-container.d.ts

@@ -1,6 +1,8 @@
 import { StepsController } from './steps.context';
 /**
- * Custom event emitted when the current step changes
+ * Custom event emitted when the current step changes.
+ * The component stops propagation of bubbled 'change' events from child inputs
+ * to prevent collision with the step change event.
  */
 export type SchmancyStepsChangeEvent = CustomEvent<{
     value: number;
@@ -11,22 +13,22 @@ export declare class SchmancyStepsContainer extends SchmancyStepsContainer_base
     stepsController: StepsController;
     set currentStep(value: number);
     get currentStep(): number;
-    private _currentStep;
     /**
      * Gap between steps. Maps to Tailwind gap classes.
-     * Options: 0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 24
      * @default 4
      */
     gap: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16 | 20 | 24;
     connectedCallback(): void;
+    /**
+     * Handle change events - stop propagation of bubbled events from children.
+     * This prevents form inputs inside steps from triggering the parent's @change handler.
+     */
+    private handleChange;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
         'schmancy-steps-container': SchmancyStepsContainer;
     }
-    interface HTMLElementEventMap {
-        'schmancy-steps:change': SchmancyStepsChangeEvent;
-    }
 }
 export {};

package/types/src/surface/surface.d.ts

@@ -2,8 +2,8 @@ import { TSurfaceColor } from '@schmancy/types';
 export declare const SchmancySurfaceTypeContext: {
     __context__: TSurfaceColor;
 };
-export type SchmancySurfaceFill = 'all' | 'width' | 'height' | 'auto';
-declare const SchmancySurface_base: import("../../mixins").Constructor<CustomElementConstructor> & import("../../mixins").Constructor<import("@mixins/tailwind.mixin").ITailwindElementMixin> & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
+export type { SchmancySurfaceFill, SchmancySurfaceRounded, SchmancySurfaceElevation } from '@mixins/surface.mixin';
+declare const SchmancySurface_base: import("../../mixins").Constructor<import("@mixins/surface.mixin").ISurfaceMixin> & import("../../mixins").Constructor<CustomElementConstructor> & import("../../mixins").Constructor<import("@mixins/tailwind.mixin").ITailwindElementMixin> & import("../../mixins").Constructor<import("lit").LitElement> & import("../../mixins").Constructor<import("../../mixins").IBaseMixin>;
 /**
  * `<schmancy-surface>` component
  *
@@ -12,6 +12,8 @@ declare const SchmancySurface_base: import("../../mixins").Constructor<CustomEle
  * based on the specified surface variant. Additionally, when the `scroller` property is true, the component
  * enables internal scrolling by applying overflow and scroll-behavior styles.
  *
+ * SurfaceMixin automatically provides surfaceStyles CSS.
+ *
  * @element schmancy-surface
  * @slot - Default slot for projecting child content.
  *
@@ -21,36 +23,12 @@ declare const SchmancySurface_base: import("../../mixins").Constructor<CustomEle
  * </schmancy-surface>
  */
 export declare class SchmancySurface extends SchmancySurface_base {
-    /**
-     * Fill the width and/or height of the parent container.
-     * Options: 'all', 'width', 'height', 'auto'.
-     * @default 'auto'
-     */
-    fill: 'all' | 'width' | 'height' | 'auto';
-    /**
-     * Specifies the rounding style of the component's corners.
-     * Options: 'none', 'top', 'left', 'right', 'bottom', 'all'.
-     * @default 'none'
-     */
-    rounded: 'none' | 'top' | 'left' | 'right' | 'bottom' | 'all';
     /**
      * Specifies the surface type for styling.
      * Provided to descendant components via context.
-     * Options: 'surface', 'surfaceDim', 'surfaceBright', 'containerLowest',
-     * 'containerLow', 'container', 'containerHigh', 'containerHighest',
-     * 'glass', 'transparent', 'glassOforim', 'primary', 'primaryContainer',
-     * 'secondary', 'secondaryContainer', 'tertiary', 'tertiaryContainer',
-     * 'error', 'errorContainer', 'success', 'successContainer',
-     * 'warning', 'warningContainer', 'info', 'infoContainer'.
      * @default 'container'
      */
     type: TSurfaceColor;
-    /**
-     * Defines the elevation level (shadow depth) of the surface.
-     * Valid values: 0, 1, 2, 3, 4, 5.
-     * @default 0
-     */
-    elevation: 0 | 1 | 2 | 3 | 4 | 5;
     protected render(): unknown;
 }
 declare global {
@@ -58,4 +36,3 @@ declare global {
         'schmancy-surface': SchmancySurface;
     }
 }
-export {};

package/types/src/surface/surface.styles.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Luminous Glass surface type styles.
+ *
+ * Depth model: blur intensity + opacity replaces M3 tonal hierarchy.
+ * - solid:    opaque ground (0 blur, 100% opacity)
+ * - subtle:   frosted panel (4px blur, ~72% opacity)
+ * - glass:    full frosted glass (20px blur, ~55% opacity)
+ * - luminous: glass + glow halo (24px blur, ~22% opacity)
+ */
+export declare const surfaceTypeStyles: import("lit").CSSResult;
+/**
+ * Surface fill styles - dimension control
+ */
+export declare const surfaceFillStyles: import("lit").CSSResult;
+/**
+ * Surface rounded corner styles
+ */
+export declare const surfaceRoundedStyles: import("lit").CSSResult;
+/**
+ * Luminous glow elevation — replaces M3 dark drop shadows with primary-colored glow.
+ * No ::after tint overlay — depth comes from glow intensity, not surface tint.
+ */
+export declare const surfaceElevationStyles: import("lit").CSSResult;
+/**
+ * Surface clickable styles - luminous hover, spring active
+ */
+export declare const surfaceClickableStyles: import("lit").CSSResult;
+/**
+ * Combined surface styles - includes all surface styling capabilities
+ */
+export declare const surfaceStyles: import("lit").CSSResult;

package/types/src/tabs/tab.d.ts

@@ -4,6 +4,7 @@ export default class SchmancyTab extends SchmancyTab_base {
     value: any;
     active: boolean;
     mode: any;
+    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
     protected render(): unknown;
 }
 declare global {

package/types/src/textarea/textarea.d.ts

@@ -76,12 +76,13 @@ export default class SchmancyTextarea extends SchmancyTextarea_base {
     cols: number;
     /**
      * The number of rows (height) of the control.
+     * When not set, the textarea auto-sizes to fit its content via field-sizing: content.
      * @attr rows
      * @type {number}
-     * @default 2
+     * @default undefined
      * @public
      */
-    rows: number;
+    rows: number | undefined;
     /**
      * Makes the textarea fill the height of its container.
      * @attr fillHeight