@mhmo91/schmancy 0.10.37 → 0.10.39

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

@@ -1,5 +1,4 @@
 import { SchmancyElement } from '@mixins/index';
-import { PropertyValueMap } from 'lit';
 import { ButtonVariant } from './button';
 /**
  * An icon button component.
@@ -8,6 +7,7 @@ import { ButtonVariant } from './button';
  * @csspart base - The underlying native `<button>` (or `<a>` when `href` is set).
  */
 export declare class SchmnacyIconButton extends SchmancyElement {
+    #private;
     static styles: import("lit").CSSResult[];
     protected static shadowRootOptions: {
         mode: string;
@@ -18,7 +18,6 @@ export declare class SchmnacyIconButton extends SchmancyElement {
         slotAssignment?: SlotAssignmentMode;
     };
     private nativeElement;
-    private _ariaLabel;
     /**
      * The size of the icon.
      * @attr
@@ -67,11 +66,11 @@ export declare class SchmnacyIconButton extends SchmancyElement {
      * @attr
      */
     icon?: string;
-    private _capturedIcon?;
-    private _observer?;
+    private capturedIcon?;
+    private observer?;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    private _captureIcon;
+    private captureIcon;
     set ariaLabel(value: string);
     get ariaLabel(): string;
     /** Sets focus in the button. */
@@ -79,8 +78,8 @@ export declare class SchmnacyIconButton extends SchmancyElement {
     /** Removes focus from the button. */
     blur(): void;
     click(): void;
-    private _preventDefault;
-    protected firstUpdated(_changedProperties: PropertyValueMap<unknown> | Map<PropertyKey, unknown>): void;
+    private preventDefault;
+    protected firstUpdated(): void;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {

package/types/src/card/card.d.ts

@@ -50,14 +50,14 @@ export default class SchmancyCard extends SchmancyElement {
     private nextRippleId;
     connectedCallback(): void;
     updated(changedProperties: Map<string, unknown>): void;
-    private _updateAriaAttributes;
-    private _addRipple;
-    private _navigate;
-    private _triggerAction;
+    private updateAriaAttributes;
+    private addRipple;
+    private navigate;
+    private triggerAction;
     private handleClick;
     private handleKeyDown;
     private handleKeyUp;
-    private _setPressed;
+    private setPressed;
     private handleMouseDown;
     private handleMouseUp;
     private handleMouseLeave;

package/types/src/content-drawer/drawer.d.ts

@@ -37,7 +37,7 @@ export declare class SchmancyContentDrawer extends SchmancyElement {
     private setupRenderListener;
     private updateMaxHeight;
     private updateMode;
-    private _overlaySubscription;
+    private overlaySubscription;
     private handleRender;
     private dismissOverlay;
     getOffsetTop(element: HTMLElement | null): number;

package/types/src/details/details.d.ts

@@ -1,6 +1,7 @@
 import { SchmancyElement } from '@mixins/index';
 declare const SchmancyDetails_base: import("@mixins/index").Constructor<import("@mixins/index").ISurfaceMixin> & typeof SchmancyElement;
 export default class SchmancyDetails extends SchmancyDetails_base {
+    #private;
     static styles: import("lit").CSSResult[];
     protected static shadowRootOptions: {
         mode: "open";
@@ -20,35 +21,15 @@ export default class SchmancyDetails extends SchmancyDetails_base {
     overlay: boolean;
     summaryPadding: string;
     contentPadding: string;
-    private _open$;
-    private _indicatorRef;
-    private _contentRef;
-    private _currentAnimation?;
-    private _indicatorIsOpen;
-    private _closing;
-    private _closeSub?;
-    /** True when browser handles close animation natively via ::details-content */
-    private _nativeAnim;
     /**
      * Lazy rendering: tracks if content has ever been opened.
      * Once true, content stays rendered (even when closed) for smooth animations.
      */
-    private _hasOpened;
+    private hasOpened;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
     render(): import("lit-html").TemplateResult<1>;
-    private _handleSummaryClick;
-    private _handleToggle;
-    /**
-     * Fallback close: trigger CSS grid+opacity transition, then close native <details>.
-     * The CSS transition (400ms) handles the visual collapse — no WAAPI needed.
-     */
-    private _startClose;
-    private _handleIndicatorSlotChange;
-    private _updateIndicatorSlot;
-    /** Idempotent indicator rotation — skips if already at target state */
-    private _animateIndicator;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/types/src/directives/ai-badge.d.ts

@@ -6,10 +6,10 @@ import { AsyncDirective } from 'lit/async-directive.js';
 import type { ElementPart } from 'lit';
 declare class AIBadgeDirective extends AsyncDirective {
     private state;
-    render(_message?: string): symbol;
+    render(message?: string): symbol;
     update(part: ElementPart, [message]: [string?]): symbol;
     private cleanup;
     disconnected(): void;
 }
-export declare const aiBadge: (_message?: string) => import("lit-html/directive").DirectiveResult<typeof AIBadgeDirective>;
+export declare const aiBadge: (message?: string) => import("lit-html/directive").DirectiveResult<typeof AIBadgeDirective>;
 export {};

package/types/src/directives/animate-text.d.ts

@@ -23,7 +23,7 @@ declare class AnimateTextDirective extends AsyncDirective {
     private animations;
     private disconnecting$;
     private initialized;
-    render(_options: AnimateTextOptions): symbol;
+    render(options: AnimateTextOptions): symbol;
     update(part: ElementPart, [options]: [AnimateTextOptions]): symbol;
     disconnected(): void;
     reconnected(): void;
@@ -63,5 +63,5 @@ declare class AnimateTextDirective extends AsyncDirective {
     private animateCyberGlitch$;
     private animateTypewriter$;
 }
-export declare const animateText: (_options: AnimateTextOptions) => import("lit-html/directive").DirectiveResult<typeof AnimateTextDirective>;
+export declare const animateText: (options: AnimateTextOptions) => import("lit-html/directive").DirectiveResult<typeof AnimateTextDirective>;
 export {};

package/types/src/directives/art/art.directive.d.ts

@@ -7,7 +7,7 @@ import { AsyncDirective } from 'lit/async-directive.js';
 import type { ArtOptions } from './types';
 declare class ArtDirective extends AsyncDirective {
     private state;
-    render(_options: ArtOptions): symbol;
+    render(options: ArtOptions): symbol;
     update(part: ElementPart, [options]: [ArtOptions]): symbol;
     private initializeResources;
     private setupVisibilityObserver;
@@ -15,5 +15,5 @@ declare class ArtDirective extends AsyncDirective {
     private cleanup;
     disconnected(): void;
 }
-export declare const art: (_options: ArtOptions) => import("lit-html/directive").DirectiveResult<typeof ArtDirective>;
+export declare const art: (options: ArtOptions) => import("lit-html/directive").DirectiveResult<typeof ArtDirective>;
 export {};

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

@@ -66,7 +66,7 @@ declare class FutureCellDirective extends AsyncDirective {
     private resizeObserver;
     /** Effective speed scales with fill %: low fill = calm, high fill = vivid */
     private getEffectiveSpeed;
-    render(_options: FutureCellOptions): symbol;
+    render(options: FutureCellOptions): symbol;
     update(part: ElementPart, [options]: [FutureCellOptions]): symbol;
     private storeOriginalStyles;
     private setupElement;
@@ -92,5 +92,5 @@ declare class FutureCellDirective extends AsyncDirective {
     private updateFill;
     disconnected(): void;
 }
-export declare const futureCell: (_options: FutureCellOptions) => import("lit-html/directive").DirectiveResult<typeof FutureCellDirective>;
+export declare const futureCell: (options: FutureCellOptions) => import("lit-html/directive").DirectiveResult<typeof FutureCellDirective>;
 export {};

package/types/src/directives/confirm-click.d.ts

@@ -7,7 +7,7 @@ export interface ConfirmClickOptions {
 }
 declare class ConfirmClickDirective extends Directive {
     constructor(partInfo: PartInfo);
-    render(_callback: () => void, _options?: ConfirmClickOptions): any;
+    render(callback: () => void, options?: ConfirmClickOptions): any;
     update(part: ElementPart, [callback, options]: [() => void, ConfirmClickOptions?]): any;
     private optionsEqual;
     private setupClickListener;
@@ -34,5 +34,5 @@ declare class ConfirmClickDirective extends Directive {
  * html`<schmancy-icon-button ${confirmClick(() => this.deleteItem(item))}>delete</schmancy-icon-button>`
  * ```
  */
-export declare const confirmClick: (_callback: () => void, _options?: ConfirmClickOptions) => import("lit-html/directive").DirectiveResult<typeof ConfirmClickDirective>;
+export declare const confirmClick: (callback: () => void, options?: ConfirmClickOptions) => import("lit-html/directive").DirectiveResult<typeof ConfirmClickDirective>;
 export {};

package/types/src/directives/cursor-glow.d.ts

@@ -27,12 +27,12 @@ declare class CursorGlowDirective extends AsyncDirective {
     private prevKey?;
     private didSetPosition;
     private cachedRect?;
-    render(_options?: CursorGlowOptions): any;
+    render(options?: CursorGlowOptions): any;
     update(part: ElementPart, [options]: [CursorGlowOptions?]): any;
     reconnected(): void;
     private ensureGlowElement;
     private setupTracking;
     disconnected(): void;
 }
-export declare const cursorGlow: (_options?: CursorGlowOptions) => import("lit-html/directive").DirectiveResult<typeof CursorGlowDirective>;
+export declare const cursorGlow: (options?: CursorGlowOptions) => import("lit-html/directive").DirectiveResult<typeof CursorGlowDirective>;
 export {};

package/types/src/directives/cycle-text.d.ts

@@ -24,7 +24,7 @@ declare class CycleTextDirective extends AsyncDirective {
     private addDisplayEl;
     private disconnecting$;
     private initialized;
-    render(_options?: CycleTextOptions): symbol;
+    render(options?: CycleTextOptions): symbol;
     update(part: ElementPart, [options]: [CycleTextOptions?]): symbol;
     disconnected(): void;
     reconnected(): void;
@@ -40,5 +40,5 @@ declare class CycleTextDirective extends AsyncDirective {
     private typewriterTransition;
     private cleanup;
 }
-export declare const cycleText: (_options?: CycleTextOptions) => import("lit-html/directive").DirectiveResult<typeof CycleTextDirective>;
+export declare const cycleText: (options?: CycleTextOptions) => import("lit-html/directive").DirectiveResult<typeof CycleTextDirective>;
 export {};

package/types/src/directives/depth-of-field.d.ts

@@ -27,12 +27,12 @@ declare class DepthOfFieldDirective extends AsyncDirective {
     private duration;
     private isBlurred;
     private transitionSet;
-    render(_options: DepthOfFieldOptions): any;
+    render(options: DepthOfFieldOptions): any;
     update(part: ElementPart, [options]: [DepthOfFieldOptions]): any;
     private applyBlur;
     private clearBlur;
     disconnected(): void;
     reconnected(): void;
 }
-export declare const depthOfField: (_options: DepthOfFieldOptions) => import("lit-html/directive").DirectiveResult<typeof DepthOfFieldDirective>;
+export declare const depthOfField: (options: DepthOfFieldOptions) => import("lit-html/directive").DirectiveResult<typeof DepthOfFieldDirective>;
 export {};

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

@@ -13,9 +13,9 @@ export declare class DragDirective extends Directive {
     update(part: ElementPart, [id]: [string]): symbol;
     disconnected(): void;
     reconnected(): void;
-    render(_id: string): symbol;
+    render(id: string): symbol;
 }
-export declare const drag: (_id: string) => import("lit-html/directive").DirectiveResult<typeof DragDirective>;
+export declare const drag: (id: string) => import("lit-html/directive").DirectiveResult<typeof DragDirective>;
 export declare class DropDirective extends Directive {
     private element?;
     private destinationId;
@@ -23,6 +23,6 @@ export declare class DropDirective extends Directive {
     update(part: ElementPart, [destinationId]: [string]): symbol;
     disconnected(): void;
     reconnected(): void;
-    render(_destinationId: string): symbol;
+    render(destinationId: string): symbol;
 }
-export declare const drop: (_destinationId: string) => import("lit-html/directive").DirectiveResult<typeof DropDirective>;
+export declare const drop: (destinationId: string) => import("lit-html/directive").DirectiveResult<typeof DropDirective>;

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

@@ -57,7 +57,7 @@ declare class FyiDirective extends AsyncDirective {
     private state;
     private destroy$;
     private subscriptions;
-    render(_options?: FyiOptions): symbol;
+    render(options?: FyiOptions): symbol;
     update(part: ElementPart, [options]: [FyiOptions?]): symbol;
     private scheduleShow;
     private waitForOverlaysClear;
@@ -72,5 +72,5 @@ declare class FyiDirective extends AsyncDirective {
     disconnected(): void;
     reconnected(): void;
 }
-export declare const fyi: (_options?: FyiOptions) => import("lit-html/directive").DirectiveResult<typeof FyiDirective>;
+export declare const fyi: (options?: FyiOptions) => import("lit-html/directive").DirectiveResult<typeof FyiDirective>;
 export {};

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

@@ -30,11 +30,11 @@ declare class GravityDirective extends AsyncDirective {
     private animation?;
     private hasAnimated;
     private options?;
-    render(_options?: GravityOptions): any;
+    render(options?: GravityOptions): any;
     update(part: ElementPart, [options]: [GravityOptions?]): any;
     reconnected(): void;
     private animate;
     disconnected(): void;
 }
-export declare const gravity: (_options?: GravityOptions) => import("lit-html/directive").DirectiveResult<typeof GravityDirective>;
+export declare const gravity: (options?: GravityOptions) => import("lit-html/directive").DirectiveResult<typeof GravityDirective>;
 export {};

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

@@ -68,7 +68,7 @@ declare class HummingbirdDirective extends AsyncDirective {
      * getBoundingClientRect() returns viewport coords; we subtract the host's rect.
      */
     private toHostRelative;
-    render(_options?: boolean | HummingbirdOptions): symbol;
+    render(options?: boolean | HummingbirdOptions): symbol;
     update(part: ElementPart, [options]: [boolean | HummingbirdOptions | undefined]): symbol;
     private initStateMachine;
     private handleStateTransition;
@@ -176,5 +176,5 @@ declare class HummingbirdDirective extends AsyncDirective {
     private cleanup;
     disconnected(): void;
 }
-export declare const hummingbird: (_options?: boolean | HummingbirdOptions) => import("lit-html/directive").DirectiveResult<typeof HummingbirdDirective>;
+export declare const hummingbird: (options?: boolean | HummingbirdOptions) => import("lit-html/directive").DirectiveResult<typeof HummingbirdDirective>;
 export {};

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

@@ -48,7 +48,7 @@ export interface IntersectCallbacks {
 type IntersectCallback = (isVisible: boolean, entry: IntersectionObserverEntry) => void;
 declare class IntersectDirective extends AsyncDirective {
     private state;
-    render(_callbackOrOptions: IntersectCallback | IntersectCallbacks, _options?: IntersectOptions): symbol;
+    render(callbackOrOptions: IntersectCallback | IntersectCallbacks, options?: IntersectOptions): symbol;
     update(part: ElementPart, [callbackOrOptions, options]: [IntersectCallback | IntersectCallbacks, IntersectOptions?]): symbol;
     private triggerCallback;
     private cleanup;
@@ -56,5 +56,5 @@ declare class IntersectDirective extends AsyncDirective {
     disconnected(): void;
     reconnected(): void;
 }
-export declare const intersect: (_callbackOrOptions: IntersectCallbacks | IntersectCallback, _options?: IntersectOptions) => import("lit-html/directive").DirectiveResult<typeof IntersectDirective>;
+export declare const intersect: (callbackOrOptions: IntersectCallbacks | IntersectCallback, options?: IntersectOptions) => import("lit-html/directive").DirectiveResult<typeof IntersectDirective>;
 export {};

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

@@ -26,7 +26,7 @@ export interface LiquidOptions {
 }
 declare class LiquidDirective extends AsyncDirective {
     private state;
-    render(_options?: LiquidOptions): symbol;
+    render(options?: LiquidOptions): symbol;
     update(part: ElementPart, [options]: [LiquidOptions?]): symbol;
     private activate;
     private applyStyles;
@@ -34,5 +34,5 @@ declare class LiquidDirective extends AsyncDirective {
     disconnected(): void;
     reconnected(): void;
 }
-export declare const liquid: (_options?: LiquidOptions) => import("lit-html/directive").DirectiveResult<typeof LiquidDirective>;
+export declare const liquid: (options?: LiquidOptions) => import("lit-html/directive").DirectiveResult<typeof LiquidDirective>;
 export {};

package/types/src/directives/living-border.d.ts

@@ -28,12 +28,12 @@ declare class LivingBorderDirective extends AsyncDirective {
     private prevKey?;
     private didSetPosition;
     private lastOptions?;
-    render(_options?: LivingBorderOptions): any;
+    render(options?: LivingBorderOptions): any;
     update(part: ElementPart, [options]: [LivingBorderOptions?]): any;
     reconnected(): void;
     private createBorderOverlay;
     private cleanup;
     disconnected(): void;
 }
-export declare const livingBorder: (_options?: LivingBorderOptions) => import("lit-html/directive").DirectiveResult<typeof LivingBorderDirective>;
+export declare const livingBorder: (options?: LivingBorderOptions) => import("lit-html/directive").DirectiveResult<typeof LivingBorderDirective>;
 export {};

package/types/src/directives/long-press.d.ts

@@ -7,7 +7,7 @@ export interface LongPressOptions {
 }
 declare class LongPressDirective extends Directive {
     constructor(partInfo: PartInfo);
-    render(_callback: () => void, _options?: LongPressOptions): any;
+    render(callback: () => void, options?: LongPressOptions): any;
     update(part: ElementPart, [callback, options]: [() => void, LongPressOptions?]): any;
     private optionsEqual;
     private setupLongPress;
@@ -34,5 +34,5 @@ declare class LongPressDirective extends Directive {
  * html`<div ${longPress(() => this.showMenu(), { duration: 800, movementThreshold: 15 })}></div>`
  * ```
  */
-export declare const longPress: (_callback: () => void, _options?: LongPressOptions) => import("lit-html/directive").DirectiveResult<typeof LongPressDirective>;
+export declare const longPress: (callback: () => void, options?: LongPressOptions) => import("lit-html/directive").DirectiveResult<typeof LongPressDirective>;
 export {};

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

@@ -25,11 +25,11 @@ declare class MagneticDirective extends AsyncDirective {
     private radius;
     private prevKey?;
     private cachedRect?;
-    render(_options?: MagneticOptions): any;
+    render(options?: MagneticOptions): any;
     update(part: ElementPart, [options]: [MagneticOptions?]): any;
     reconnected(): void;
     private setupMagnetic;
     disconnected(): void;
 }
-export declare const magnetic: (_options?: MagneticOptions) => import("lit-html/directive").DirectiveResult<typeof MagneticDirective>;
+export declare const magnetic: (options?: MagneticOptions) => import("lit-html/directive").DirectiveResult<typeof MagneticDirective>;
 export {};

package/types/src/directives/missed-punch.d.ts

@@ -15,7 +15,7 @@ export interface MissedPunchOptions {
 }
 declare class MissedPunchDirective extends AsyncDirective {
     private state;
-    render(_options: MissedPunchOptions): symbol;
+    render(options: MissedPunchOptions): symbol;
     update(part: ElementPart, [options]: [MissedPunchOptions]): symbol;
     private createOverlay;
     private generateShardPoints;
@@ -24,5 +24,5 @@ declare class MissedPunchDirective extends AsyncDirective {
     private cleanup;
     disconnected(): void;
 }
-export declare const missedPunch: (_options: MissedPunchOptions) => import("lit-html/directive").DirectiveResult<typeof MissedPunchDirective>;
+export declare const missedPunch: (options: MissedPunchOptions) => import("lit-html/directive").DirectiveResult<typeof MissedPunchDirective>;
 export {};

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

@@ -64,7 +64,7 @@ export interface NebulaOptions {
 declare class NebulaDirective extends AsyncDirective {
     private state;
     private coordinator;
-    render(_options?: NebulaOptions): symbol;
+    render(options?: NebulaOptions): symbol;
     update(part: ElementPart, [options]: [NebulaOptions?]): symbol;
     onVisibilityChange(isVisible: boolean): void;
     private show;
@@ -76,5 +76,5 @@ declare class NebulaDirective extends AsyncDirective {
     disconnected(): void;
     reconnected(): void;
 }
-export declare const nebula: (_options?: NebulaOptions) => import("lit-html/directive").DirectiveResult<typeof NebulaDirective>;
+export declare const nebula: (options?: NebulaOptions) => import("lit-html/directive").DirectiveResult<typeof NebulaDirective>;
 export {};

package/types/src/directives/overflow-within.d.ts

@@ -67,11 +67,11 @@ declare class OverflowWithinDirective extends AsyncDirective {
     private element;
     private disconnecting$;
     private currentName?;
-    render(_options?: OverflowWithinOptions): symbol;
+    render(options?: OverflowWithinOptions): symbol;
     update(part: ElementPart, [options]: [OverflowWithinOptions?]): symbol;
     private subscribe;
     protected disconnected(): void;
     protected reconnected(): void;
 }
-export declare const overflowWithin: (_options?: OverflowWithinOptions) => import("lit-html/directive").DirectiveResult<typeof OverflowWithinDirective>;
+export declare const overflowWithin: (options?: OverflowWithinOptions) => import("lit-html/directive").DirectiveResult<typeof OverflowWithinDirective>;
 export {};

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

@@ -55,10 +55,10 @@ declare class RevealDirective extends AsyncDirective {
     /** True if this is the very first update call — used to detect always-true initial mount. */
     private firstUpdate;
     constructor(partInfo: PartInfo);
-    render(_show?: boolean, _options?: RevealOptions): symbol;
+    render(show?: boolean, options?: RevealOptions): symbol;
     update(part: ElementPart, [show, options]: [boolean | undefined, RevealOptions?]): symbol;
     disconnected(): void;
     reconnected(): void;
 }
-export declare const reveal: (_show?: boolean, _options?: RevealOptions) => import("lit-html/directive").DirectiveResult<typeof RevealDirective>;
+export declare const reveal: (show?: boolean, options?: RevealOptions) => import("lit-html/directive").DirectiveResult<typeof RevealDirective>;
 export {};

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

@@ -64,7 +64,7 @@ export interface UrgentOptions {
 declare class UrgentDirective extends AsyncDirective {
     private state;
     private coordinator;
-    render(_activeOrOptions?: boolean | UrgentOptions, _color?: UrgentColor, _shake?: boolean): symbol;
+    render(activeOrOptions?: boolean | UrgentOptions, color?: UrgentColor, shake?: boolean): symbol;
     update(part: ElementPart, args: [boolean | UrgentOptions | undefined, UrgentColor?, boolean?]): symbol;
     private initializeElement;
     checkBurstTimer(now: number): void;
@@ -78,7 +78,7 @@ declare class UrgentDirective extends AsyncDirective {
     private cleanup;
     disconnected(): void;
 }
-declare const urgentDirective: (_activeOrOptions?: boolean | UrgentOptions, _color?: UrgentColor, _shake?: boolean) => import("lit-html/directive").DirectiveResult<typeof UrgentDirective>;
+declare const urgentDirective: (activeOrOptions?: boolean | UrgentOptions, color?: UrgentColor, shake?: boolean) => import("lit-html/directive").DirectiveResult<typeof UrgentDirective>;
 type UrgentFn = {
     (active?: boolean, color?: UrgentColor, shake?: boolean): ReturnType<typeof urgentDirective>;
     (options: UrgentOptions): ReturnType<typeof urgentDirective>;

package/types/src/directives/working-snake.d.ts

@@ -34,7 +34,7 @@ export interface WorkingSnakeOptions {
 }
 declare class WorkingSnakeDirective extends AsyncDirective {
     private state;
-    render(_options: WorkingSnakeOptions): symbol;
+    render(options: WorkingSnakeOptions): symbol;
     update(part: ElementPart, [options]: [WorkingSnakeOptions]): symbol;
     private createOverlay;
     private setupVisibilityObserver;
@@ -42,5 +42,5 @@ declare class WorkingSnakeDirective extends AsyncDirective {
     private cleanup;
     disconnected(): void;
 }
-export declare const workingSnake: (_options: WorkingSnakeOptions) => import("lit-html/directive").DirectiveResult<typeof WorkingSnakeDirective>;
+export declare const workingSnake: (options: WorkingSnakeOptions) => import("lit-html/directive").DirectiveResult<typeof WorkingSnakeDirective>;
 export {};

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

@@ -8,20 +8,20 @@ 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;
+    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;
+    private animateOpen;
+    private animateClose;
     render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 declare global {

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

@@ -11,24 +11,24 @@ export default class SchmancyExpand extends SchmancyElement {
     indicatorRotate: number;
     backdrop: boolean;
     inline: boolean;
-    private _summaryRef;
-    private _contentSlotRef;
-    private _root;
-    private _movedNodes;
-    private _currentIndicatorAnim;
+    private summaryRef;
+    private contentSlotRef;
+    private root;
+    private movedNodes;
+    private currentIndicatorAnim;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    private _getOrCreateRoot;
+    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;
+    private toggle;
+    private handleSummaryClick;
+    private expandPortal;
+    handleClose(): Promise<void>;
+    private animateIndicator;
     render(): import("lit-html").TemplateResult<1>;
 }
 declare global {