@mhmo91/schmancy 0.10.36 → 0.10.38

package/src/window/window.ts

@@ -73,22 +73,22 @@ export default class SchmancyWindow extends SchmancyElement {
 	/** Whether the body is expanded. */
 	@property({ type: Boolean, reflect: true }) open = false
 
-	private _currentAnimation?: Animation
+	private currentAnimation?: Animation
 
 	/** Lazy rendering: body content not in DOM until first expand. */
-	@state() private _hasOpened = false
+	@state() private hasOpened = false
 
 	// Internal position -- plain fields, updated directly during drag
-	private _position: Position = { x: 16, y: 16 }
-	@state() private _currentCorner: SnapCorner = 'bottom-right'
+	private position: Position = { x: 16, y: 16 }
+	@state() private currentCorner: SnapCorner = 'bottom-right'
 
 	// Track applied corner to avoid unnecessary style.removeProperty calls during drag
-	private _appliedCorner: string = ''
+	private appliedCorner: string = ''
 
 	// Refs
-	private _containerRef = createRef<HTMLElement>()
-	private _bodyRef = createRef<HTMLElement>()
-	private _headRef = createRef<HTMLElement>()
+	private containerRef = createRef<HTMLElement>()
+	private bodyRef = createRef<HTMLElement>()
+	private headRef = createRef<HTMLElement>()
 
 	// ============================================
 	// COMPUTED
@@ -99,7 +99,7 @@ export default class SchmancyWindow extends SchmancyElement {
 	}
 
 	private get isBottomCorner(): boolean {
-		return this._currentCorner.startsWith('bottom')
+		return this.currentCorner.startsWith('bottom')
 	}
 
 	private get closedClipPath(): string {
@@ -121,24 +121,24 @@ export default class SchmancyWindow extends SchmancyElement {
 	// POSITION MANAGEMENT
 	// ============================================
 
-	private _applyContainerPosition() {
-		const container = this._containerRef.value
+	private applyContainerPosition() {
+		const container = this.containerRef.value
 		if (!container) return
 		// Only clear position properties when corner changes (avoids 4 style invalidations per drag frame)
-		if (this._appliedCorner !== this._currentCorner) {
+		if (this.appliedCorner !== this.currentCorner) {
 			container.style.removeProperty('left')
 			container.style.removeProperty('right')
 			container.style.removeProperty('top')
 			container.style.removeProperty('bottom')
-			this._appliedCorner = this._currentCorner
+			this.appliedCorner = this.currentCorner
 		}
-		const { x, y } = this._position
-		if (this._currentCorner.includes('right')) {
+		const { x, y } = this.position
+		if (this.currentCorner.includes('right')) {
 			container.style.right = `${x}px`
 		} else {
 			container.style.left = `${x}px`
 		}
-		if (this._currentCorner.includes('bottom')) {
+		if (this.currentCorner.includes('bottom')) {
 			container.style.bottom = `${y + theme.bottomOffset}px`
 		} else {
 			container.style.top = `${y}px`
@@ -147,63 +147,63 @@ export default class SchmancyWindow extends SchmancyElement {
 
 	private static readonly VALID_CORNERS = new Set<string>(['top-left', 'top-right', 'bottom-left', 'bottom-right'])
 
-	private _loadPosition() {
+	private loadPosition() {
 		const saved = windowManager.loadPosition(this.id)
 		if (saved) {
-			this._position = { x: saved.x, y: saved.y }
+			this.position = { x: saved.x, y: saved.y }
 			if (SchmancyWindow.VALID_CORNERS.has(saved.anchor)) {
-				this._currentCorner = saved.anchor as SnapCorner
+				this.currentCorner = saved.anchor as SnapCorner
 			}
 		}
 	}
 
-	private _savePosition() {
-		windowManager.savePosition(this.id, { ...this._position, anchor: this._currentCorner })
+	private savePosition() {
+		windowManager.savePosition(this.id, { ...this.position, anchor: this.currentCorner })
 	}
 
-	private _validateBounds() {
-		const container = this._containerRef.value
+	private validateBounds() {
+		const container = this.containerRef.value
 		if (!container) return
 		const rect = container.getBoundingClientRect()
 		if (rect.width === 0) return
 		const vw = window.innerWidth
 		const vh = window.innerHeight
-		const isRight = this._currentCorner.includes('right')
-		const isBottom = this._currentCorner.includes('bottom')
-		const actualLeft = isRight ? vw - this._position.x - rect.width : this._position.x
-		const actualTop = isBottom ? vh - this._position.y - rect.height : this._position.y
+		const isRight = this.currentCorner.includes('right')
+		const isBottom = this.currentCorner.includes('bottom')
+		const actualLeft = isRight ? vw - this.position.x - rect.width : this.position.x
+		const actualTop = isBottom ? vh - this.position.y - rect.height : this.position.y
 		const newLeft = Math.max(0, Math.min(actualLeft, vw - rect.width))
 		const newTop = Math.max(0, Math.min(actualTop, vh - rect.height))
-		this._position = {
+		this.position = {
 			x: isRight ? vw - newLeft - rect.width : newLeft,
 			y: isBottom ? vh - newTop - rect.height : newTop,
 		}
-		this._applyContainerPosition()
+		this.applyContainerPosition()
 	}
 
 	// ============================================
 	// CORNER SNAPPING
 	// ============================================
 
-	private _reorientToNearestCorner(skipAnimation = false): void {
+	private reorientToNearestCorner(skipAnimation = false): void {
 		// Free position mode: skip corner snapping
 		if (this.freePosition) {
-			this._savePosition()
-			const rect = this._containerRef.value?.getBoundingClientRect()
+			this.savePosition()
+			const rect = this.containerRef.value?.getBoundingClientRect()
 			if (rect) {
 				windowManager.updateBounds(this.id, { left: rect.left, top: rect.top, width: rect.width, height: rect.height })
 			}
 			return
 		}
 
-		const container = this._containerRef.value
+		const container = this.containerRef.value
 		if (!container) return
 
 		// F -- record current screen position before DOM mutation
 		const rect = container.getBoundingClientRect()
 
 		// L -- calculate nearest corner using head visual center
-		const currentIsBottom = this._currentCorner.includes('bottom')
+		const currentIsBottom = this.currentCorner.includes('bottom')
 		const headCenterX = rect.left + rect.width / 2
 		const headCenterY = currentIsBottom
 			? rect.bottom - HEAD_HEIGHT / 2
@@ -213,16 +213,16 @@ export default class SchmancyWindow extends SchmancyElement {
 		const newCorner: SnapCorner = `${vert}-${side}` as SnapCorner
 
 		// Snap corner and reset offset to standard edge gap
-		this._currentCorner = newCorner
-		this._position = { x: 16, y: 16 }
-		this._applyContainerPosition()
+		this.currentCorner = newCorner
+		this.position = { x: 16, y: 16 }
+		this.applyContainerPosition()
 		// Sync clip-path to new corner
 		if (!this.open) {
 			container.style.clipPath = this.closedClipPath
 		}
 
 		if (skipAnimation || reducedMotion$.value) {
-			this._savePosition()
+			this.savePosition()
 			const snapRect = container.getBoundingClientRect()
 			windowManager.updateBounds(this.id, { left: snapRect.left, top: snapRect.top, width: snapRect.width, height: snapRect.height })
 			return
@@ -256,17 +256,17 @@ export default class SchmancyWindow extends SchmancyElement {
 			takeUntil(this.disconnecting),
 		).subscribe()
 
-		this._savePosition()
+		this.savePosition()
 	}
 
 	// ============================================
 	// DRAG PIPELINE
 	// ============================================
 
-	private _drag$(): Observable<never> {
+	private drag$(): Observable<never> {
 		return new Observable(() => {
-			const head = this._headRef.value
-			const container = this._containerRef.value
+			const head = this.headRef.value
+			const container = this.containerRef.value
 			if (!head || !container) return
 
 			let didDrag = false
@@ -286,7 +286,7 @@ export default class SchmancyWindow extends SchmancyElement {
 				.pipe(
 					map(e => {
 						const rect = container.getBoundingClientRect()
-						const isBottom = this._currentCorner.includes('bottom')
+						const isBottom = this.currentCorner.includes('bottom')
 						const wasOpen = this.open
 						didDrag = false
 						return {
@@ -318,13 +318,13 @@ export default class SchmancyWindow extends SchmancyElement {
 								const dy = clientY - startY
 								if (Math.sqrt(dx * dx + dy * dy) > DRAG_THRESHOLD && !didDrag) {
 									didDrag = true
-									this._applyDragVisuals(true)
+									this.applyDragVisuals(true)
 									// Collapse on first confirmed drag move
 									if (wasOpen) {
 										this.open = false
 										container.style.clipPath = this.closedClipPath
 										container.style.overflow = 'hidden'
-										const body = this._bodyRef.value
+										const body = this.bodyRef.value
 										if (body) {
 											body.inert = true
 											body.style.visibility = 'hidden'
@@ -338,17 +338,17 @@ export default class SchmancyWindow extends SchmancyElement {
 								const maxTop = isBottom ? vh - rect.height : vh - HEAD_HEIGHT
 								const top = Math.max(minTop, Math.min(clientY - offsetY, maxTop))
 
-								this._position = {
-									x: this._currentCorner.includes('right') ? vw - left - rect.width : left,
+								this.position = {
+									x: this.currentCorner.includes('right') ? vw - left - rect.width : left,
 									y: isBottom ? vh - top - rect.height : top,
 								}
-								this._applyContainerPosition()
+								this.applyContainerPosition()
 							}),
 							takeUntil(end$),
 							finalize(() => {
 								if (didDrag) {
-									this._reorientToNearestCorner()
-									this._applyDragVisuals(false)
+									this.reorientToNearestCorner()
+									this.applyDragVisuals(false)
 									didDrag = false
 								} else {
 									didDrag = false
@@ -375,24 +375,24 @@ export default class SchmancyWindow extends SchmancyElement {
 		from(this.updateComplete).pipe(
 			take(1),
 			tap(() => {
-				this._currentCorner = this.corner
-				this._loadPosition()
-				this._applyContainerPosition()
-				this._initDOMState()
+				this.currentCorner = this.corner
+				this.loadPosition()
+				this.applyContainerPosition()
+				this.initDOMState()
 				// Register with window manager
-				const container = this._containerRef.value
+				const container = this.containerRef.value
 				if (container) {
 					const rect = container.getBoundingClientRect()
 					const bounds: WindowBounds = { left: rect.left, top: rect.top, width: rect.width, height: rect.height }
-					windowManager.register(this.id, bounds, this.freePosition ? 'free' : this._currentCorner)
+					windowManager.register(this.id, bounds, this.freePosition ? 'free' : this.currentCorner)
 				}
 			}),
 			switchMap(() => merge(
-				this._drag$(),
+				this.drag$(),
 				windowManager.selectWindow(this.id).pipe(
 					tap(record => {
 						if (!record) return
-						const container = this._containerRef.value
+						const container = this.containerRef.value
 						if (container) container.style.zIndex = String(record.zIndex)
 					}),
 				),
@@ -405,10 +405,10 @@ export default class SchmancyWindow extends SchmancyElement {
 		merge(
 			fromEvent(window, 'resize').pipe(
 				auditTime(0, animationFrameScheduler),
-				tap(() => this._validateBounds()),
+				tap(() => this.validateBounds()),
 			),
 			theme.bottomOffset$.pipe(
-				tap(() => this._applyContainerPosition()),
+				tap(() => this.applyContainerPosition()),
 			),
 		).pipe(takeUntil(this.disconnecting)).subscribe()
 	}
@@ -418,15 +418,15 @@ export default class SchmancyWindow extends SchmancyElement {
 		windowManager.unregister(this.id)
 	}
 
-	private _initDOMState() {
-		const container = this._containerRef.value
-		const body = this._bodyRef.value
+	private initDOMState() {
+		const container = this.containerRef.value
+		const body = this.bodyRef.value
 		if (!container) return
 
-		this._applyContainerPosition()
+		this.applyContainerPosition()
 
 		if (this.open) {
-			this._hasOpened = true
+			this.hasOpened = true
 			container.style.overflow = ''
 			if (body) {
 				body.inert = false
@@ -446,12 +446,12 @@ export default class SchmancyWindow extends SchmancyElement {
 	// ANIMATION
 	// ============================================
 
-	private _animateOpen() {
-		const container = this._containerRef.value
-		const body = this._bodyRef.value
+	private animateOpen() {
+		const container = this.containerRef.value
+		const body = this.bodyRef.value
 		if (!container) return
 
-		this._hasOpened = true
+		this.hasOpened = true
 		this.open = true
 
 		// Overlap avoidance
@@ -466,13 +466,13 @@ export default class SchmancyWindow extends SchmancyElement {
 		if (overlaps.length > 0) {
 			const resolved = resolveOverlap(projectedBounds, overlaps, { width: window.innerWidth, height: window.innerHeight })
 			if (Math.abs(resolved.left - projectedBounds.left) > 10 || Math.abs(resolved.top - projectedBounds.top) > 10) {
-				const isRight = this._currentCorner.includes('right')
-				const isBottom = this._currentCorner.includes('bottom')
-				this._position = {
+				const isRight = this.currentCorner.includes('right')
+				const isBottom = this.currentCorner.includes('bottom')
+				this.position = {
 					x: isRight ? window.innerWidth - resolved.left - resolved.width : resolved.left,
 					y: isBottom ? window.innerHeight - resolved.top - resolved.height : resolved.top,
 				}
-				this._applyContainerPosition()
+				this.applyContainerPosition()
 			}
 		}
 
@@ -488,7 +488,7 @@ export default class SchmancyWindow extends SchmancyElement {
 			return
 		}
 
-		this._currentAnimation?.cancel()
+		this.currentAnimation?.cancel()
 		container.style.overflow = 'hidden'
 		container.style.willChange = 'opacity'
 		const openKeyframes: Keyframe[] = [
@@ -500,7 +500,7 @@ export default class SchmancyWindow extends SchmancyElement {
 			easing: SPRING_SNAPPY.easingFallback,
 			fill: 'forwards',
 		})
-		this._currentAnimation = anim
+		this.currentAnimation = anim
 
 		from(anim.finished).pipe(
 			take(1),
@@ -518,21 +518,21 @@ export default class SchmancyWindow extends SchmancyElement {
 		this.dispatchScopedEvent('window-toggle', { state: 'expanded' })
 	}
 
-	private _animateClose() {
-		const container = this._containerRef.value
+	private animateClose() {
+		const container = this.containerRef.value
 		if (!container) return
 
 		if (reducedMotion$.value) {
 			container.style.clipPath = this.closedClipPath
 			container.style.overflow = 'hidden'
 			this.open = false
-			const body = this._bodyRef.value
+			const body = this.bodyRef.value
 			if (body) { body.inert = true; body.style.visibility = 'hidden' }
 			this.dispatchScopedEvent('window-toggle', { state: 'collapsed' })
 			return
 		}
 
-		this._currentAnimation?.cancel()
+		this.currentAnimation?.cancel()
 		container.style.overflow = 'hidden'
 		container.style.willChange = 'opacity'
 		const closeKeyframes: Keyframe[] = [
@@ -544,14 +544,14 @@ export default class SchmancyWindow extends SchmancyElement {
 			easing: 'cubic-bezier(0.4, 0, 0.8, 0.15)',
 			fill: 'forwards',
 		})
-		this._currentAnimation = anim
+		this.currentAnimation = anim
 
 		from(anim.finished).pipe(
 			take(1),
 			tap(() => {
 				this.open = false
 				container.style.willChange = ''
-				const body = this._bodyRef.value
+				const body = this.bodyRef.value
 				if (body) { body.inert = true; body.style.visibility = 'hidden' }
 			}),
 			catchError(() => EMPTY),
@@ -566,9 +566,9 @@ export default class SchmancyWindow extends SchmancyElement {
 	// ============================================
 
 	/** Apply drag visuals directly on DOM refs — avoids full Lit re-render for cursor + opacity */
-	private _applyDragVisuals(dragging: boolean) {
-		const head = this._headRef.value
-		const container = this._containerRef.value
+	private applyDragVisuals(dragging: boolean) {
+		const head = this.headRef.value
+		const container = this.containerRef.value
 		if (head) {
 			head.classList.toggle('cursor-grabbing', dragging)
 			head.classList.toggle('cursor-move', !dragging)
@@ -578,9 +578,9 @@ export default class SchmancyWindow extends SchmancyElement {
 		}
 	}
 
-	private _handleFocus = () => windowManager.focus(this.id)
+	private handleFocus = () => windowManager.focus(this.id)
 
-	private _handleHeadKeydown = (e: KeyboardEvent) => {
+	private handleHeadKeydown = (e: KeyboardEvent) => {
 		if (e.key === 'Enter' || e.key === ' ') {
 			e.preventDefault()
 			this.toggle()
@@ -591,9 +591,9 @@ export default class SchmancyWindow extends SchmancyElement {
 			const step = e.shiftKey ? 20 : 5
 			const dx = e.key === 'ArrowRight' ? step : e.key === 'ArrowLeft' ? -step : 0
 			const dy = e.key === 'ArrowDown' ? step : e.key === 'ArrowUp' ? -step : 0
-			this._position = { x: this._position.x + dx, y: this._position.y + dy }
-			this._applyContainerPosition()
-			this._savePosition()
+			this.position = { x: this.position.x + dx, y: this.position.y + dy }
+			this.applyContainerPosition()
+			this.savePosition()
 		}
 	}
 
@@ -602,18 +602,18 @@ export default class SchmancyWindow extends SchmancyElement {
 	// ============================================
 
 	toggle() {
-		if (this.open) this._animateClose()
-		else this._animateOpen()
+		if (this.open) this.animateClose()
+		else this.animateOpen()
 	}
 
 	expand() {
 		if (this.open) return
-		this._animateOpen()
+		this.animateOpen()
 	}
 
 	close() {
 		if (!this.open) return
-		this._animateClose()
+		this.animateClose()
 	}
 
 	// ============================================
@@ -621,7 +621,7 @@ export default class SchmancyWindow extends SchmancyElement {
 	// ============================================
 
 	protected render(): unknown {
-		const isBottom = this._currentCorner.startsWith('bottom')
+		const isBottom = this.currentCorner.startsWith('bottom')
 
 		const containerClasses = classMap({
 			fixed: true,
@@ -656,23 +656,23 @@ export default class SchmancyWindow extends SchmancyElement {
 
 		return html`
 			<schmancy-surface
-				${ref(this._containerRef)}
+				${ref(this.containerRef)}
 				type="glass"
 				.elevation=${this.elevation}
 				class=${containerClasses}
 				style=${containerStyles}
 				aria-expanded=${this.open}
-				@pointerdown=${this._handleFocus}
+				@pointerdown=${this.handleFocus}
 			>
 				<!-- Details section (visually above summary for bottom corners) -->
 				<section
-					${ref(this._bodyRef)}
+					${ref(this.bodyRef)}
 					class="flex-1 min-h-0 overflow-hidden flex flex-col"
 					style=${bodyStyles}
 					role="region"
 					aria-label="Expandable content"
 				>
-					${this._hasOpened ? html`<slot name="details"></slot>` : nothing}
+					${this.hasOpened ? html`<slot name="details"></slot>` : nothing}
 				</section>
 
 				<!-- Summary section -- always interactive, always visible -->
@@ -681,14 +681,14 @@ export default class SchmancyWindow extends SchmancyElement {
 					style=${styleMap({ 'pointer-events': 'auto', height: `${HEAD_HEIGHT}px` })}
 				>
 					<div
-						${ref(this._headRef)}
+						${ref(this.headRef)}
 						${cursorGlow({ radius: 200, intensity: 0.10 })}
 						class=${headClasses}
 						role="button"
 						tabindex="0"
 						title="Drag to move, click to expand"
 						aria-label="${this.open ? 'Collapse window' : 'Expand window'}"
-						@keydown=${this._handleHeadKeydown}
+						@keydown=${this.handleHeadKeydown}
 					>
 						<div class="flex-1 min-w-0">
 							<slot></slot>

package/types/mixins/SchmancyElement.d.ts

@@ -1,10 +1,11 @@
 import { LitElement, type CSSResultGroup, type CSSResultOrNative } from 'lit';
+import { type SignalWatcherApi } from '@lit-labs/signals';
 import { type IBaseMixin } from './baseElement';
 import type { Constructor } from './constructor';
 type StaticFinalizeStyles = {
     finalizeStyles(styles?: CSSResultGroup): CSSResultOrNative[];
 };
-declare const SchmancyElementBase: CustomElementConstructor & Constructor<LitElement> & Constructor<IBaseMixin> & StaticFinalizeStyles;
+declare const SchmancyElementBase: CustomElementConstructor & Constructor<LitElement> & Constructor<IBaseMixin> & Constructor<SignalWatcherApi> & StaticFinalizeStyles;
 /**
  * Base class for Schmancy components. A concrete named class — not a mixin
  * factory — so DevTools shows `SchmancyElement` in the prototype chain and
@@ -37,7 +38,7 @@ declare const SchmancyElementBase: CustomElementConstructor & Constructor<LitEle
  * (`NO_SIGNAL_WATCHER_WRAP`) blocks it as belt-and-suspenders.
  */
 export declare class SchmancyElement extends SchmancyElementBase {
-    private _abortController;
+    private abortController;
     /** AbortSignal that fires when the element disconnects. */
     readonly disconnectedSignal: AbortSignal;
     constructor();

package/types/mixins/formField.mixin.d.ts

@@ -115,7 +115,7 @@ export interface IFormFieldMixin extends Element {
      * Subclasses should not override this — extend the truth table by changing
      * `validateOn` instead.
      */
-    _shouldShowError(): boolean;
+    shouldShowError(): boolean;
     toFormEntries(): Array<[string, FormDataEntryValue]>;
     resetForm(): void;
     emitChange(detail: any): void;

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

@@ -80,7 +80,7 @@ declare class AreaService implements AreaSubscription {
     /**
      * Update browser history state (called by area components)
      */
-    _updateBrowserHistory(areaName: string, route: ActiveRoute, historyStrategy?: string, clearQueryParams?: string[] | boolean | null, customPath?: string): void;
+    updateBrowserHistory(areaName: string, route: ActiveRoute, historyStrategy?: string, clearQueryParams?: string[] | boolean | null, customPath?: string): void;
     /**
      * Create a clean URL from area states
      */

package/types/src/area/lazy.d.ts

@@ -11,12 +11,6 @@ export interface LazyComponent<T extends CustomElementConstructor = CustomElemen
         default: T;
     }>;
     preload(): Promise<void>;
-    _promise?: Promise<{
-        default: T;
-    }>;
-    _module?: {
-        default: T;
-    };
 }
 /**
  * Create a lazy-loaded component that will be imported on demand

package/types/src/audio/sound.service.d.ts

@@ -37,14 +37,13 @@ import type { Feeling, FeelingSound, SoundTheme } from '../types/mood-audio.type
  * - Persists settings to session storage
  */
 declare class SoundService {
+    #private;
     private static instance;
     /** Audio context for Web Audio API */
     private audioContext;
     readonly theme$: import("rxjs").Observable<SoundTheme>;
     readonly volume$: import("rxjs").Observable<number>;
     readonly muted$: import("rxjs").Observable<boolean>;
-    /** BehaviorSubject for current theme name (for debugging/display) */
-    private readonly _themeName$;
     readonly themeName$: import("rxjs").Observable<string>;
     get theme(): SoundTheme | null;
     get volume(): number;

package/types/src/breadcrumb/breadcrumb.d.ts

@@ -13,7 +13,7 @@ export declare class SchmancyBreadcrumb extends SchmancyElement {
     separator: string;
     connectedCallback(): void;
     render(): import("lit-html").TemplateResult<1>;
-    private _insertSeparators;
+    private insertSeparators;
 }
 /**
  * Individual breadcrumb item. Renders as a link when `href` is provided,

package/types/src/button/button.d.ts

@@ -15,6 +15,7 @@ export type ButtonColor = 'primary' | 'secondary' | 'success' | 'error' | 'warni
  * @csspart base - The underlying native `<button>` (or `<a>` when `href` is set).
  */
 export declare class SchmancyButton extends SchmancyElement {
+    #private;
     static styles: import("lit").CSSResult[];
     protected static shadowRootOptions: {
         mode: string;
@@ -32,7 +33,7 @@ export declare class SchmancyButton extends SchmancyElement {
      * while a submit is in flight. Stays focusable; disabled buttons drop from
      * the tab order and are unreachable to AT (WCAG 2.2 AA).
      */
-    private _formBusyObserver?;
+    private formBusyObserver?;
     constructor();
     /** Associated form, when placed inside a <form>. */
     get form(): HTMLFormElement | null;
@@ -40,7 +41,6 @@ export declare class SchmancyButton extends SchmancyElement {
     connectedCallback(): void;
     disconnectedCallback(): void;
     private nativeElement;
-    private _ariaLabel;
     /**
      * The variant of the button.
      * @attr
@@ -106,7 +106,7 @@ export declare class SchmancyButton extends SchmancyElement {
     protected get imgClasses(): string[];
     firstUpdated(): void;
     click(): void;
-    private _preventDefault;
+    private preventDefault;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {