@mich8060/unified-design-system 0.2.11 → 0.2.14

package/dist/design-system/ai/manifest/governance.manifest.d.ts

@@ -0,0 +1,10 @@
+import type { GovernanceConfig, VersionLineage } from "./types";
+export declare const AI_MANIFEST_VERSION = "1.0.0";
+export declare const AI_GOVERNANCE_VERSION = "1.0.0";
+export declare const AI_POLICY_VERSION = "1.0.0";
+export declare const AI_CONTRACT_SCHEMA_VERSION = "1.0.0";
+export declare const AI_COMPONENT_API_SCHEMA_VERSION = "1.0.0";
+export declare const AI_SCHEMA_VERSION = "1.0.0";
+export declare const AI_API_SCHEMA_VERSION = "1.0.0";
+export declare const UDSGovernance: GovernanceConfig;
+export declare function getVersionLineage(): VersionLineage;

package/dist/design-system/ai/manifest/index.d.ts

@@ -0,0 +1,9 @@
+export { UDSManifest, UDS_AI_MANIFEST } from "./system.manifest";
+export { UDSGovernance, getVersionLineage, AI_MANIFEST_VERSION, AI_GOVERNANCE_VERSION, AI_POLICY_VERSION, AI_CONTRACT_SCHEMA_VERSION, AI_COMPONENT_API_SCHEMA_VERSION, AI_SCHEMA_VERSION, AI_API_SCHEMA_VERSION, } from "./governance.manifest";
+export { ComponentRegistry } from "./components.manifest";
+export { PatternRegistry } from "./patterns.manifest";
+export { LayoutRules } from "./layout.manifest";
+export { CompositionRules } from "./composition.manifest";
+export { PropAliasRules, getCanonicalPropName, getAliasEntries } from "./prop-aliases.manifest";
+export { TokenIntentMap } from "./tokens.intent.manifest";
+export type { ComponentManifestItem, ComponentRegistryType, LayoutManifestRules, ManifestGovernance, PatternManifestItem, PatternRegistryType, TokenIntentMapType, UDSManifestType, UINodeTree, ValidationError, ValidationResult, GovernanceConfig, VersionLineage, } from "./types";

package/dist/design-system/ai/manifest/layout.manifest.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutManifestRules } from "./types";
+export declare const LayoutRules: LayoutManifestRules;

package/dist/design-system/ai/manifest/patterns.manifest.d.ts

@@ -0,0 +1,2 @@
+import type { PatternRegistryType } from "./types";
+export declare const PatternRegistry: PatternRegistryType;

package/dist/design-system/ai/manifest/prop-aliases.manifest.d.ts

@@ -0,0 +1,10 @@
+export interface PropAliasManifest {
+    global: Record<string, string>;
+    byComponent: Record<string, Record<string, string>>;
+}
+export declare const PropAliasRules: PropAliasManifest;
+export declare function getCanonicalPropName(componentName: string, propName: string): string;
+export declare function getAliasEntries(componentName: string): Array<{
+    alias: string;
+    canonical: string;
+}>;

package/dist/design-system/ai/manifest/system.manifest.d.ts

@@ -0,0 +1,5 @@
+import type { UDSManifestType } from "./types";
+export declare const UDSManifest: UDSManifestType;
+export declare const UDSAIContract: UDSManifestType;
+export declare const UDS_AI_CONTRACT: UDSManifestType;
+export declare const UDS_AI_MANIFEST: UDSManifestType;

package/dist/design-system/ai/manifest/tokens.intent.manifest.d.ts

@@ -0,0 +1,2 @@
+import type { TokenIntentMapType } from "./types";
+export declare const TokenIntentMap: TokenIntentMapType;

package/dist/design-system/ai/manifest/types.d.ts

@@ -0,0 +1,136 @@
+export interface ManifestGovernance {
+    maxPrimaryActionsPerSection: number;
+    spacingUnit: number;
+    defaultRadius: string;
+}
+export interface ComponentSlotMeta {
+    required: boolean;
+    description?: string;
+}
+export interface ComponentManifestItem {
+    name: string;
+    category: string;
+    intent: string;
+    priority?: string;
+    variants: string[];
+    sizes?: string[];
+    slots?: Record<string, ComponentSlotMeta>;
+    usage: {
+        preferredContexts: string[];
+        maxPerSection?: number;
+    };
+    constraints?: {
+        onlyOnePrimaryPerSection?: boolean;
+        allowedChildren?: string[];
+        disallowedChildren?: string[];
+    };
+    accessibility?: {
+        role: string;
+        keyboardSupport: string[];
+    };
+    tokenDependencies: string[];
+}
+export type ComponentRegistryType = Record<string, ComponentManifestItem>;
+export interface PatternStructureNode {
+    type: string;
+    role?: string;
+    props?: Record<string, unknown>;
+}
+export interface PatternManifestItem {
+    name: string;
+    layout: "vertical" | "horizontal" | "grid";
+    requiredComponents: string[];
+    structure: PatternStructureNode[];
+    spacing: string;
+    widthConstraint?: string;
+    rules?: Record<string, unknown>;
+}
+export type PatternRegistryType = Record<string, PatternManifestItem>;
+export interface LayoutManifestRules {
+    spacingSystem: {
+        unit: number;
+        allowedTokens: string[];
+        defaultToken: string;
+    };
+    verticalRhythm: {
+        sectionGapToken: string;
+        contentGapToken: string;
+        compactGapToken: string;
+    };
+    allowedComposition: Record<string, string[]>;
+    allowedParents: Record<string, string[]>;
+    disallowedNesting: Array<{
+        parent: string;
+        child: string;
+    }>;
+    maxWidth: {
+        content: string;
+        form: string;
+        dialog: string;
+    };
+    actionPlacement: {
+        primaryActionPosition: "end";
+        secondaryActionPosition: "start" | "end";
+        maxPrimaryActionsPerSection: number;
+    };
+}
+export interface TokenIntentMapType {
+    surface: Record<string, string>;
+    action: Record<string, string>;
+    text: Record<string, string>;
+    border: Record<string, string>;
+    state: Record<string, string>;
+}
+export interface UDSManifestType {
+    version: string;
+    tokenVersion: string;
+    components: ComponentRegistryType;
+    patterns: PatternRegistryType;
+    layout: LayoutManifestRules;
+    tokens: TokenIntentMapType;
+    governance: ManifestGovernance;
+}
+export interface ValidationError {
+    code: "MAX_PRIMARY_ACTIONS" | "INVALID_COMPOSITION" | "INVALID_SPACING_TOKEN" | "DISALLOWED_NESTING";
+    path: string;
+    message: string;
+    meta?: Record<string, unknown>;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+export interface UINodeTree {
+    type: string;
+    props?: Record<string, unknown>;
+    children?: UINodeTree[];
+}
+export interface GovernanceConfig {
+    systemVersion: string;
+    tokenVersion: string;
+    manifestVersion: string;
+    governanceVersion: string;
+    policyVersion: string;
+    enforcement: {
+        strictMode: boolean;
+        allowAdHocValues: boolean;
+        allowInlineStyles: boolean;
+        allowUnknownComponents: boolean;
+    };
+    limits: {
+        maxPrimaryActionsPerSection: number;
+        maxActionsPerToolbar: number;
+        maxNestingDepth: number;
+    };
+    compliance: {
+        accessibilityStandard: string;
+        spacingUnit: number;
+    };
+}
+export interface VersionLineage {
+    udsVersion: string;
+    tokenVersion: string;
+    manifestVersion: string;
+    governanceVersion: string;
+    policyVersion: string;
+}

package/dist/design-system/ai/policies/policy.engine.d.ts

@@ -0,0 +1,3 @@
+import type { GovernanceConfig, UINodeTree } from "../manifest/types";
+import type { PolicyViolation } from "./policy.types";
+export declare function runPolicyEngine(tree: UINodeTree, governanceConfig?: GovernanceConfig): PolicyViolation[];

package/dist/design-system/ai/policies/policy.types.d.ts

@@ -0,0 +1,14 @@
+import type { GovernanceConfig, UINodeTree } from "../manifest/types";
+export interface PolicyViolation {
+    severity: "error" | "warning";
+    code: string;
+    message: string;
+    path: string;
+    component?: string;
+    token?: string;
+}
+export interface PolicyRuleContext {
+    tree: UINodeTree;
+    governanceConfig: GovernanceConfig;
+}
+export type PolicyRule = (context: PolicyRuleContext) => PolicyViolation[];

package/dist/design-system/ai/policies/rules/accessibility.rules.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyRule } from "../policy.types";
+export declare const enforceAccessibilityRule: PolicyRule;

package/dist/design-system/ai/policies/rules/action.rules.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyRule } from "../policy.types";
+export declare const enforcePrimaryActionLimitRule: PolicyRule;

package/dist/design-system/ai/policies/rules/composition.rules.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyRule } from "../policy.types";
+export declare const enforceCompositionRule: PolicyRule;

package/dist/design-system/ai/policies/rules/props.rules.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyRule } from "../policy.types";
+export declare const enforceCanonicalPropsRule: PolicyRule;

package/dist/design-system/ai/policies/rules/spacing.rules.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyRule } from "../policy.types";
+export declare const enforceSpacingTokenRule: PolicyRule;

package/dist/design-system/ai/sdk/index.d.ts

@@ -0,0 +1 @@
+export { createUDSRuntimeHelperSDK, type UDSRuntimeHelperSDK, type CreateUDSRuntimeHelperSDKOptions, type CanonicalizedPropsResult, } from "./runtime-sdk";

package/dist/design-system/ai/sdk/runtime-sdk.d.ts

@@ -0,0 +1,21 @@
+import { ComponentRegistry } from "../manifest/components.manifest";
+import { UDSManifest } from "../manifest/system.manifest";
+import type { GovernanceConfig, VersionLineage } from "../manifest/types";
+import { type AIValidationResult } from "../validation/validateAIOutput";
+export interface CanonicalizedPropsResult {
+    canonicalProps: Record<string, unknown>;
+    aliasesApplied: Record<string, string>;
+}
+export interface UDSRuntimeHelperSDK {
+    readonly governance: GovernanceConfig;
+    getVersionLineage(): VersionLineage;
+    getManifest(): typeof UDSManifest;
+    getComponent(componentName: string): (typeof ComponentRegistry)[string] | undefined;
+    canonicalizeProps(componentName: string, props: Record<string, unknown>): CanonicalizedPropsResult;
+    validate(output: unknown): AIValidationResult;
+    validateOrThrow(output: unknown): AIValidationResult;
+}
+export interface CreateUDSRuntimeHelperSDKOptions {
+    governance?: GovernanceConfig;
+}
+export declare function createUDSRuntimeHelperSDK(options?: CreateUDSRuntimeHelperSDKOptions): UDSRuntimeHelperSDK;

package/dist/design-system/ai/telemetry/usageMetrics.d.ts

@@ -0,0 +1,9 @@
+export interface UsageMetric {
+    metricType: "component_used" | "rule_violation" | "token_override" | "strict_mode_failure";
+    name: string;
+    value?: number;
+    timestamp?: string;
+}
+export declare function recordUsageMetric(metric: UsageMetric): void;
+export declare function getUsageMetrics(): Record<string, number>;
+export declare function resetUsageMetrics(): void;

package/dist/design-system/ai/validation/deterministicFeedback.d.ts

@@ -0,0 +1,15 @@
+import type { PolicyViolation } from "../policies/policy.types";
+export interface DeterministicViolationFeedback {
+    id: string;
+    code: string;
+    path: string;
+    message: string;
+    fix: string;
+    severity: "error" | "warning";
+}
+export declare function sortAndDedupeViolations(violations: PolicyViolation[]): PolicyViolation[];
+export declare function buildDeterministicFeedback(violations: PolicyViolation[]): {
+    fingerprint: string;
+    summary: string;
+    items: DeterministicViolationFeedback[];
+};

package/dist/design-system/ai/validation/driftDetection.d.ts

@@ -0,0 +1,3 @@
+import type { UINodeTree } from "../manifest/types";
+import type { PolicyViolation } from "../policies/policy.types";
+export declare function detectDrift(tree: UINodeTree): PolicyViolation[];

package/dist/design-system/ai/validation/index.d.ts

@@ -0,0 +1,5 @@
+export { validateTree } from "./validateTree";
+export { validateSchema } from "./schemaValidation";
+export { detectDrift } from "./driftDetection";
+export { validateAIOutput } from "./validateAIOutput";
+export { buildDeterministicFeedback, sortAndDedupeViolations } from "./deterministicFeedback";

package/dist/design-system/ai/validation/schemaValidation.d.ts

@@ -0,0 +1,7 @@
+import type { UINodeTree } from "../manifest/types";
+import type { PolicyViolation } from "../policies/policy.types";
+export declare function validateSchema(output: unknown): {
+    valid: boolean;
+    violations: PolicyViolation[];
+    tree?: UINodeTree;
+};

package/dist/design-system/ai/validation/validateAIOutput.d.ts

@@ -0,0 +1,25 @@
+import type { GovernanceConfig, VersionLineage } from "../manifest/types";
+import type { PolicyViolation } from "../policies/policy.types";
+export interface AIValidationResult {
+    status: "pass" | "fail";
+    violations: PolicyViolation[];
+    warnings: PolicyViolation[];
+    deterministicFeedback?: {
+        fingerprint: string;
+        summary: string;
+        items: Array<{
+            id: string;
+            code: string;
+            path: string;
+            message: string;
+            fix: string;
+            severity: "error" | "warning";
+        }>;
+    };
+    governanceVersionUsed: string;
+    manifestVersionUsed: string;
+    policyVersionUsed: string;
+    timestamp: string;
+    versionLineage: VersionLineage;
+}
+export declare function validateAIOutput(output: unknown, governanceConfig?: GovernanceConfig): AIValidationResult;

package/dist/design-system/ai/validation/validateTree.d.ts

@@ -0,0 +1,2 @@
+import type { UINodeTree, ValidationResult } from "../manifest/types";
+export declare function validateTree(tree: UINodeTree): ValidationResult;

package/dist/design-system/components/Button/Button.d.ts

@@ -1,3 +1,3 @@
 import type { ButtonProps } from "./Button.types";
 import "./_button.scss";
-export default function Button({ label, appearance, layout, size, icon, iconSize, icons, children, tracking, className, onClick, disabled, "aria-label": ariaLabel, ...rest }: ButtonProps): import("react/jsx-runtime").JSX.Element;
+export default function Button({ label, appearance, layout, size, icon, iconSize, icons, children, tracking, loading, className, onClick, disabled, "aria-label": ariaLabel, ...rest }: ButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/design-system/components/Button/Button.types.d.ts

@@ -13,4 +13,5 @@ export interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement
     icons?: ReactNode;
     children?: ReactNode;
     tracking?: ButtonTracking;
+    loading?: boolean;
 }

package/dist/design-system/components/Chip/Chip.d.ts

@@ -3,8 +3,9 @@ import type { ChipProps } from "./Chip.types";
 /**
  * Chip component for displaying labels, tags, or filters
  * @param {string} label - The text content of the chip
- * @param {string} appearance - Visual style variant: 'outline' or 'primary'
- * @param {string} shape - Shape variant: 'pill' (fully rounded) or 'rounded' (slightly rounded)
+ * @param {boolean} selected - Selected state (unselected by default)
+ * @param {boolean} rounded - Shape toggle: true (fully rounded), false (less rounded)
+ * @param {string} size - Size variant: 'default' or 'compact'
  * @param {string} iconPlacement - Icon placement: 'both', 'left', 'right', or 'none'
  * @param {string} icon - Icon name to display (when iconPlacement is not 'none')
  * @param {number|string} badge - Badge count to display
@@ -14,4 +15,4 @@ import type { ChipProps } from "./Chip.types";
  * @param {boolean} disabled - Whether the chip is disabled
  * @param {object} props - Additional props to pass to the chip element
  */
-export default function Chip({ label, appearance, shape, iconPlacement, icon, badge, badgeVariant, className, onClick, disabled, ...props }: ChipProps): import("react/jsx-runtime").JSX.Element;
+export default function Chip({ label, selected, rounded, size, iconPlacement, icon, badge, badgeVariant, className, onClick, disabled, ...props }: ChipProps): import("react/jsx-runtime").JSX.Element;

package/dist/design-system/components/Chip/Chip.types.d.ts

@@ -1,13 +1,17 @@
-import type { HTMLAttributes, ReactNode } from "react";
-export interface ChipProps extends HTMLAttributes<HTMLDivElement> {
-    label?: unknown;
-    appearance?: string;
-    shape?: string;
-    iconPlacement?: string;
+import type { HTMLAttributes, MouseEventHandler, ReactNode } from "react";
+import type { BadgeVariant } from "../Badge/Badge.types";
+export type ChipSize = "default" | "compact";
+export type ChipIconPlacement = "both" | "left" | "right" | "none";
+export interface ChipProps extends HTMLAttributes<HTMLElement> {
+    label?: ReactNode;
+    selected?: boolean;
+    rounded?: boolean;
+    size?: ChipSize;
+    iconPlacement?: ChipIconPlacement;
     icon?: string | ReactNode;
-    badge?: unknown;
-    badgeVariant?: string;
+    badge?: number | string;
+    badgeVariant?: BadgeVariant;
     className?: string;
-    onClick?: (...args: unknown[]) => void;
+    onClick?: MouseEventHandler<HTMLElement>;
     disabled?: boolean;
 }

package/dist/design-system/components/Dialog/Dialog.types.d.ts

@@ -1,20 +1,21 @@
 import type { HTMLAttributes, ReactNode } from "react";
+export type DialogIntent = "info" | "success" | "warning" | "destructive";
 export interface DialogProps extends HTMLAttributes<HTMLDivElement> {
     open?: boolean;
-    onClose?: (...args: unknown[]) => void;
-    intent?: string;
-    icon?: string | ReactNode;
-    title?: unknown;
-    description?: unknown;
+    onClose?: () => void;
+    intent?: DialogIntent;
+    icon?: string;
+    title?: ReactNode;
+    description?: ReactNode;
     confirmLabel?: string;
     cancelLabel?: string;
-    onConfirm?: (...args: unknown[]) => void;
-    onCancel?: (...args: unknown[]) => void;
+    onConfirm?: () => void;
+    onCancel?: () => void;
     showCancel?: boolean;
     loading?: boolean;
     closeOnBackdrop?: boolean;
     closeOnEscape?: boolean;
-    container?: unknown;
+    container?: HTMLElement;
     className?: string;
     children?: ReactNode;
 }

package/dist/design-system/components/Field/Field.d.ts

@@ -14,4 +14,4 @@ import type { FieldProps } from "./Field.types";
  * @param {React.ReactNode} children - The input element to wrap
  * @param {object} props - Additional props to pass to the field wrapper
  */
-export default function Field({ label, required, helperMessage, infoIcon, onInfoClick, maxLength, value, id, className, children, ...props }: FieldProps): import("react/jsx-runtime").JSX.Element;
+export default function Field({ label, state, required, helperMessage, maxLength, value, infoIcon, onInfoClick, id, className, children, ...props }: FieldProps): import("react/jsx-runtime").JSX.Element;

package/dist/design-system/components/Field/Field.types.d.ts

@@ -1,13 +1,15 @@
-import type { ButtonHTMLAttributes, ReactNode } from "react";
-export interface FieldProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    label?: unknown;
+import type { HTMLAttributes, ReactNode } from "react";
+export type FieldState = "default" | "error";
+export interface FieldProps extends HTMLAttributes<HTMLDivElement> {
+    label?: ReactNode;
+    state?: FieldState;
     required?: boolean;
-    helperMessage?: unknown;
-    infoIcon?: unknown;
-    onInfoClick?: (...args: unknown[]) => void;
-    maxLength?: unknown;
-    value?: unknown;
-    id?: unknown;
+    helperMessage?: ReactNode;
+    maxLength?: number;
+    value?: string | number;
+    infoIcon?: string;
+    onInfoClick?: () => void;
+    id?: string;
     className?: string;
     children?: ReactNode;
 }

package/dist/design-system/components/FileUpload/FileUpload.d.ts

@@ -12,4 +12,4 @@ import type { FileUploadProps } from "./FileUpload.types";
  * @param {string} className - Additional CSS classes
  * @param {object} props - Additional props to pass to the file input
  */
-export default function FileUpload({ onFileSelect, accept, maxSize, acceptText, instructionText, multiple, disabled, className, ...props }: FileUploadProps): import("react/jsx-runtime").JSX.Element;
+export default function FileUpload({ onFileSelect, accept, maxSize, acceptText, instructionText, size, multiple, disabled, className, ...props }: FileUploadProps): import("react/jsx-runtime").JSX.Element;

package/dist/design-system/components/FileUpload/FileUpload.types.d.ts

@@ -1,10 +1,12 @@
 import type { InputHTMLAttributes } from "react";
+export type FileUploadSize = "default" | "small";
 export interface FileUploadProps extends InputHTMLAttributes<HTMLInputElement> {
     onFileSelect?: (...args: unknown[]) => void;
     accept?: unknown[];
     maxSize?: number;
     acceptText?: unknown;
     instructionText?: string;
+    size?: FileUploadSize;
     multiple?: boolean;
     disabled?: boolean;
     className?: string;

package/dist/design-system/components/Pagination/Pagination.d.ts

@@ -5,8 +5,10 @@ import type { PaginationProps } from "./Pagination.types";
  * @param {number} currentPage - Current active page (1-indexed)
  * @param {number} totalPages - Total number of pages
  * @param {function} onPageChange - Callback when page changes: (page: number) => void
- * @param {string} variant - Variant style: "default" | "underline" | "with-jump" | "underline-with-jump" | "underline-double"
- * @param {boolean} showFirstLast - Show first/last page buttons (for variants with double buttons)
+ * @param {string} variant - Variant style: "default" | "line"
+ * @param {boolean} showJumpInput - Toggle jump-to-page input
+ * @param {boolean} showDoubleButtons - Toggle first/last page buttons
+ * @param {boolean} showFirstLast - Backward-compatible alias for showDoubleButtons
  * @param {string} className - Additional CSS classes
  */
-export default function Pagination({ currentPage, totalPages, onPageChange, variant, showFirstLast, className, }: PaginationProps): import("react/jsx-runtime").JSX.Element;
+export default function Pagination({ currentPage, totalPages, onPageChange, variant, showJumpInput, showDoubleButtons, showFirstLast, className, }: PaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/design-system/components/Pagination/Pagination.types.d.ts

@@ -1,9 +1,12 @@
 import type { ButtonHTMLAttributes } from "react";
+export type PaginationVariant = "default" | "line";
 export interface PaginationProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     currentPage?: number;
     totalPages?: number;
     onPageChange?: (...args: unknown[]) => void;
-    variant?: string;
+    variant?: PaginationVariant;
+    showJumpInput?: boolean;
+    showDoubleButtons?: boolean;
     showFirstLast?: boolean;
     className?: string;
 }

package/dist/design-system/components/ProgressCircle/ProgressCircle.d.ts

@@ -5,11 +5,12 @@ import type { ProgressCircleProps } from "./ProgressCircle.types";
  * @param {number} value - Progress value (0-100)
  * @param {number} max - Maximum value (default: 100)
  * @param {string} size - Size variant: 'xxs', 'xs', 'sm', 'md', or 'lg'
- * @param {string} shape - Shape variant: 'circle' (full circle) or 'half-circle' (semi-circle)
+ * @param {string} shape - Shape variant: 'circle' or 'half-circle'
  * @param {string} label - Optional label text to display
+ * @param {string} valueLabel - Optional custom center value text
  * @param {boolean} showLabel - Whether to show the label (if provided)
  * @param {string} className - Additional CSS classes
  * @param {string} 'aria-label' - Accessible label for screen readers
  * @param {object} props - Additional props to pass to the progress element
  */
-export default function ProgressCircle({ value, max, size, shape, label, showLabel, className, "aria-label": ariaLabel, ...props }: ProgressCircleProps): import("react/jsx-runtime").JSX.Element;
+export default function ProgressCircle({ value, max, size, shape, label, valueLabel, showLabel, className, "aria-label": ariaLabel, ...props }: ProgressCircleProps): import("react/jsx-runtime").JSX.Element;

package/dist/design-system/components/ProgressCircle/ProgressCircle.types.d.ts

@@ -1,10 +1,14 @@
 import type { HTMLAttributes } from "react";
+import type { ReactNode } from "react";
+export type ProgressCircleSize = "xxs" | "xs" | "sm" | "md" | "lg";
+export type ProgressCircleShape = "circle" | "half-circle";
 export interface ProgressCircleProps extends HTMLAttributes<HTMLDivElement> {
     value?: number;
     max?: number;
-    size?: string;
-    shape?: string;
-    label?: unknown;
+    size?: ProgressCircleSize;
+    shape?: ProgressCircleShape;
+    label?: ReactNode;
+    valueLabel?: ReactNode;
     showLabel?: boolean;
     className?: string;
 }

package/dist/design-system/components/ProgressIndicator/ProgressIndicator.d.ts

@@ -8,9 +8,10 @@ import type { ProgressIndicatorProps } from "./ProgressIndicator.types";
  * @param {string} size - Size variant: 'small', 'medium', or 'large'
  * @param {string} label - Optional label text to display above the progress bar
  * @param {boolean} showValue - Whether to show the percentage value
+ * @param {string} labelPosition - Where to place the percentage label
  * @param {boolean} showLabel - Whether to show the label (if provided)
  * @param {string} className - Additional CSS classes
  * @param {string} 'aria-label' - Accessible label for screen readers
  * @param {object} props - Additional props to pass to the progress element
  */
-export default function ProgressIndicator({ value, max, variant, size, label, showValue, showLabel, className, "aria-label": ariaLabel, ...props }: ProgressIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export default function ProgressIndicator({ value, max, variant, size, label, showValue, labelPosition, showLabel, className, "aria-label": ariaLabel, ...props }: ProgressIndicatorProps): import("react/jsx-runtime").JSX.Element;

package/dist/design-system/components/ProgressIndicator/ProgressIndicator.types.d.ts

@@ -1,11 +1,15 @@
-import type { HTMLAttributes } from "react";
+import type { HTMLAttributes, ReactNode } from "react";
+export type ProgressIndicatorVariant = "default" | "blue" | "green" | "success" | "orange" | "warning" | "red" | "error" | "purple";
+export type ProgressIndicatorSize = "small" | "medium" | "large";
+export type ProgressIndicatorLabelPosition = "false" | "right" | "bottom" | "top-floating" | "bottom-floating";
 export interface ProgressIndicatorProps extends HTMLAttributes<HTMLDivElement> {
     value?: number;
     max?: number;
-    variant?: string;
-    size?: string;
-    label?: unknown;
+    variant?: ProgressIndicatorVariant;
+    size?: ProgressIndicatorSize;
+    label?: ReactNode;
     showValue?: boolean;
     showLabel?: boolean;
+    labelPosition?: ProgressIndicatorLabelPosition;
     className?: string;
 }

package/dist/design-system/components/Tooltip/Tooltip.d.ts

@@ -9,4 +9,4 @@ import type { TooltipProps } from "./Tooltip.types";
  * @param {string} className - Additional CSS classes
  * @param {object} props - Additional props to pass to the wrapper element
  */
-export default function Tooltip({ children, content, placement, disabled, className, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export default function Tooltip({ children, content, placement, disabled, defaultVisible, className, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/design-system/components/Tooltip/Tooltip.types.d.ts

@@ -4,5 +4,6 @@ export interface TooltipProps extends HTMLAttributes<HTMLDivElement> {
     content?: unknown;
     placement?: string;
     disabled?: boolean;
+    defaultVisible?: boolean;
     className?: string;
 }