@luxonis/depthai-pipeline-lib 1.4.8

package/dist/src/styled-system/patterns/wrap.d.mts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index.d.mts';
+import type { Properties } from '../types/csstype.d.mts';
+import type { PropertyValue } from '../types/prop-type.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+import type { Tokens } from '../tokens/index.d.mts';
+
+export interface WrapProperties {
+   gap?: PropertyValue<'gap'>
+	rowGap?: PropertyValue<'gap'>
+	columnGap?: PropertyValue<'gap'>
+	align?: PropertyValue<'alignItems'>
+	justify?: PropertyValue<'justifyContent'>
+}
+
+
+interface WrapStyles extends WrapProperties, DistributiveOmit<SystemStyleObject, keyof WrapProperties > {}
+
+interface WrapPatternFn {
+  (styles?: WrapStyles): string
+  raw: (styles?: WrapStyles) => SystemStyleObject
+}
+
+
+export declare const wrap: WrapPatternFn;

package/dist/src/styled-system/patterns/wrap.mjs

@@ -0,0 +1,22 @@
+import { mapObject } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const wrapConfig = {
+transform(props) {
+  const { columnGap, rowGap, gap = columnGap || rowGap ? void 0 : "10px", align, justify, ...rest } = props;
+  return {
+    display: "flex",
+    flexWrap: "wrap",
+    alignItems: align,
+    justifyContent: justify,
+    gap,
+    columnGap,
+    rowGap,
+    ...rest
+  };
+}}
+
+export const getWrapStyle = (styles = {}) => wrapConfig.transform(styles, { map: mapObject })
+
+export const wrap = (styles) => css(getWrapStyle(styles))
+wrap.raw = getWrapStyle

package/dist/src/styled-system/recipes/accordion.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface AccordionVariant {
+  
+}
+
+type AccordionVariantMap = {
+  [key in keyof AccordionVariant]: Array<AccordionVariant[key]>
+}
+
+export type AccordionVariantProps = {
+  [key in keyof AccordionVariant]?: ConditionalValue<AccordionVariant[key]>
+}
+
+export interface AccordionRecipe {
+  __type: AccordionVariantProps
+  (props?: AccordionVariantProps): Pretty<Record<"root" | "item" | "header" | "trigger" | "content", string>>
+  raw: (props?: AccordionVariantProps) => AccordionVariantProps
+  variantMap: AccordionVariantMap
+  variantKeys: Array<keyof AccordionVariant>
+  splitVariantProps<Props extends AccordionVariantProps>(props: Props): [AccordionVariantProps, Pretty<DistributiveOmit<Props, keyof AccordionVariantProps>>]
+}
+
+/** Styles for the Accordion component */
+export declare const accordion: AccordionRecipe

package/dist/src/styled-system/recipes/accordion.mjs

@@ -0,0 +1,46 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const accordionDefaultVariants = {}
+const accordionCompoundVariants = []
+
+const accordionSlotNames = [
+  [
+    "root",
+    "accordion__root"
+  ],
+  [
+    "item",
+    "accordion__item"
+  ],
+  [
+    "header",
+    "accordion__header"
+  ],
+  [
+    "trigger",
+    "accordion__trigger"
+  ],
+  [
+    "content",
+    "accordion__content"
+  ]
+]
+const accordionSlotFns = /* @__PURE__ */ accordionSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, accordionDefaultVariants, getSlotCompoundVariant(accordionCompoundVariants, slotName))])
+
+const accordionFn = (props = {}) => {
+  return Object.fromEntries(accordionSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const accordionVariantKeys = []
+
+export const accordion = /* @__PURE__ */ Object.assign(accordionFn, {
+  __recipe__: false,
+  __name__: 'accordion',
+  raw: (props) => props,
+  variantKeys: accordionVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, accordionVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/alert-description.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface AlertDescriptionVariant {
+  
+}
+
+type AlertDescriptionVariantMap = {
+  [key in keyof AlertDescriptionVariant]: Array<AlertDescriptionVariant[key]>
+}
+
+export type AlertDescriptionVariantProps = {
+  [key in keyof AlertDescriptionVariant]?: ConditionalValue<AlertDescriptionVariant[key]>
+}
+
+export interface AlertDescriptionRecipe {
+  __type: AlertDescriptionVariantProps
+  (props?: AlertDescriptionVariantProps): string
+  raw: (props?: AlertDescriptionVariantProps) => AlertDescriptionVariantProps
+  variantMap: AlertDescriptionVariantMap
+  variantKeys: Array<keyof AlertDescriptionVariant>
+  splitVariantProps<Props extends AlertDescriptionVariantProps>(props: Props): [AlertDescriptionVariantProps, Pretty<DistributiveOmit<Props, keyof AlertDescriptionVariantProps>>]
+}
+
+/** Styles for the AlertDescription component */
+export declare const alertDescription: AlertDescriptionRecipe

package/dist/src/styled-system/recipes/alert-description.mjs

@@ -0,0 +1,19 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const alertDescriptionFn = /* @__PURE__ */ createRecipe('alertDescription', {}, [])
+
+const alertDescriptionVariantMap = {}
+
+const alertDescriptionVariantKeys = Object.keys(alertDescriptionVariantMap)
+
+export const alertDescription = /* @__PURE__ */ Object.assign(alertDescriptionFn, {
+  __recipe__: true,
+  __name__: 'alertDescription',
+  raw: (props) => props,
+  variantKeys: alertDescriptionVariantKeys,
+  variantMap: alertDescriptionVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, alertDescriptionVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/alert-dialog.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface AlertDialogVariant {
+  
+}
+
+type AlertDialogVariantMap = {
+  [key in keyof AlertDialogVariant]: Array<AlertDialogVariant[key]>
+}
+
+export type AlertDialogVariantProps = {
+  [key in keyof AlertDialogVariant]?: ConditionalValue<AlertDialogVariant[key]>
+}
+
+export interface AlertDialogRecipe {
+  __type: AlertDialogVariantProps
+  (props?: AlertDialogVariantProps): Pretty<Record<"root" | "trigger" | "portal" | "overlay" | "content" | "header" | "footer" | "title" | "description" | "action" | "cancel", string>>
+  raw: (props?: AlertDialogVariantProps) => AlertDialogVariantProps
+  variantMap: AlertDialogVariantMap
+  variantKeys: Array<keyof AlertDialogVariant>
+  splitVariantProps<Props extends AlertDialogVariantProps>(props: Props): [AlertDialogVariantProps, Pretty<DistributiveOmit<Props, keyof AlertDialogVariantProps>>]
+}
+
+/** Styles for the AlertDialog component */
+export declare const alertDialog: AlertDialogRecipe

package/dist/src/styled-system/recipes/alert-dialog.mjs

@@ -0,0 +1,70 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const alertDialogDefaultVariants = {}
+const alertDialogCompoundVariants = []
+
+const alertDialogSlotNames = [
+  [
+    "root",
+    "alertDialog__root"
+  ],
+  [
+    "trigger",
+    "alertDialog__trigger"
+  ],
+  [
+    "portal",
+    "alertDialog__portal"
+  ],
+  [
+    "overlay",
+    "alertDialog__overlay"
+  ],
+  [
+    "content",
+    "alertDialog__content"
+  ],
+  [
+    "header",
+    "alertDialog__header"
+  ],
+  [
+    "footer",
+    "alertDialog__footer"
+  ],
+  [
+    "title",
+    "alertDialog__title"
+  ],
+  [
+    "description",
+    "alertDialog__description"
+  ],
+  [
+    "action",
+    "alertDialog__action"
+  ],
+  [
+    "cancel",
+    "alertDialog__cancel"
+  ]
+]
+const alertDialogSlotFns = /* @__PURE__ */ alertDialogSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, alertDialogDefaultVariants, getSlotCompoundVariant(alertDialogCompoundVariants, slotName))])
+
+const alertDialogFn = (props = {}) => {
+  return Object.fromEntries(alertDialogSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const alertDialogVariantKeys = []
+
+export const alertDialog = /* @__PURE__ */ Object.assign(alertDialogFn, {
+  __recipe__: false,
+  __name__: 'alertDialog',
+  raw: (props) => props,
+  variantKeys: alertDialogVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, alertDialogVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/alert-title.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface AlertTitleVariant {
+  
+}
+
+type AlertTitleVariantMap = {
+  [key in keyof AlertTitleVariant]: Array<AlertTitleVariant[key]>
+}
+
+export type AlertTitleVariantProps = {
+  [key in keyof AlertTitleVariant]?: ConditionalValue<AlertTitleVariant[key]>
+}
+
+export interface AlertTitleRecipe {
+  __type: AlertTitleVariantProps
+  (props?: AlertTitleVariantProps): string
+  raw: (props?: AlertTitleVariantProps) => AlertTitleVariantProps
+  variantMap: AlertTitleVariantMap
+  variantKeys: Array<keyof AlertTitleVariant>
+  splitVariantProps<Props extends AlertTitleVariantProps>(props: Props): [AlertTitleVariantProps, Pretty<DistributiveOmit<Props, keyof AlertTitleVariantProps>>]
+}
+
+/** Styles for the AlertTitle component */
+export declare const alertTitle: AlertTitleRecipe

package/dist/src/styled-system/recipes/alert-title.mjs

@@ -0,0 +1,19 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const alertTitleFn = /* @__PURE__ */ createRecipe('alertTitle', {}, [])
+
+const alertTitleVariantMap = {}
+
+const alertTitleVariantKeys = Object.keys(alertTitleVariantMap)
+
+export const alertTitle = /* @__PURE__ */ Object.assign(alertTitleFn, {
+  __recipe__: true,
+  __name__: 'alertTitle',
+  raw: (props) => props,
+  variantKeys: alertTitleVariantKeys,
+  variantMap: alertTitleVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, alertTitleVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/alert.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface AlertVariant {
+  variant: "default" | "destructive"
+}
+
+type AlertVariantMap = {
+  [key in keyof AlertVariant]: Array<AlertVariant[key]>
+}
+
+export type AlertVariantProps = {
+  [key in keyof AlertVariant]?: ConditionalValue<AlertVariant[key]>
+}
+
+export interface AlertRecipe {
+  __type: AlertVariantProps
+  (props?: AlertVariantProps): string
+  raw: (props?: AlertVariantProps) => AlertVariantProps
+  variantMap: AlertVariantMap
+  variantKeys: Array<keyof AlertVariant>
+  splitVariantProps<Props extends AlertVariantProps>(props: Props): [AlertVariantProps, Pretty<DistributiveOmit<Props, keyof AlertVariantProps>>]
+}
+
+/** Styles for the Alert component */
+export declare const alert: AlertRecipe

package/dist/src/styled-system/recipes/alert.mjs

@@ -0,0 +1,26 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const alertFn = /* @__PURE__ */ createRecipe('alert', {
+  "variant": "default"
+}, [])
+
+const alertVariantMap = {
+  "variant": [
+    "default",
+    "destructive"
+  ]
+}
+
+const alertVariantKeys = Object.keys(alertVariantMap)
+
+export const alert = /* @__PURE__ */ Object.assign(alertFn, {
+  __recipe__: true,
+  __name__: 'alert',
+  raw: (props) => props,
+  variantKeys: alertVariantKeys,
+  variantMap: alertVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, alertVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/avatar.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface AvatarVariant {
+  
+}
+
+type AvatarVariantMap = {
+  [key in keyof AvatarVariant]: Array<AvatarVariant[key]>
+}
+
+export type AvatarVariantProps = {
+  [key in keyof AvatarVariant]?: ConditionalValue<AvatarVariant[key]>
+}
+
+export interface AvatarRecipe {
+  __type: AvatarVariantProps
+  (props?: AvatarVariantProps): Pretty<Record<"root" | "image" | "fallback", string>>
+  raw: (props?: AvatarVariantProps) => AvatarVariantProps
+  variantMap: AvatarVariantMap
+  variantKeys: Array<keyof AvatarVariant>
+  splitVariantProps<Props extends AvatarVariantProps>(props: Props): [AvatarVariantProps, Pretty<DistributiveOmit<Props, keyof AvatarVariantProps>>]
+}
+
+/** Styles for the Avatar component */
+export declare const avatar: AvatarRecipe

package/dist/src/styled-system/recipes/avatar.mjs

@@ -0,0 +1,38 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const avatarDefaultVariants = {}
+const avatarCompoundVariants = []
+
+const avatarSlotNames = [
+  [
+    "root",
+    "avatar__root"
+  ],
+  [
+    "image",
+    "avatar__image"
+  ],
+  [
+    "fallback",
+    "avatar__fallback"
+  ]
+]
+const avatarSlotFns = /* @__PURE__ */ avatarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, avatarDefaultVariants, getSlotCompoundVariant(avatarCompoundVariants, slotName))])
+
+const avatarFn = (props = {}) => {
+  return Object.fromEntries(avatarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const avatarVariantKeys = []
+
+export const avatar = /* @__PURE__ */ Object.assign(avatarFn, {
+  __recipe__: false,
+  __name__: 'avatar',
+  raw: (props) => props,
+  variantKeys: avatarVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, avatarVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/badge.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface BadgeVariant {
+  variant: "default" | "secondary" | "destructive" | "outline"
+}
+
+type BadgeVariantMap = {
+  [key in keyof BadgeVariant]: Array<BadgeVariant[key]>
+}
+
+export type BadgeVariantProps = {
+  [key in keyof BadgeVariant]?: ConditionalValue<BadgeVariant[key]>
+}
+
+export interface BadgeRecipe {
+  __type: BadgeVariantProps
+  (props?: BadgeVariantProps): string
+  raw: (props?: BadgeVariantProps) => BadgeVariantProps
+  variantMap: BadgeVariantMap
+  variantKeys: Array<keyof BadgeVariant>
+  splitVariantProps<Props extends BadgeVariantProps>(props: Props): [BadgeVariantProps, Pretty<DistributiveOmit<Props, keyof BadgeVariantProps>>]
+}
+
+/** Styles for the Badge component */
+export declare const badge: BadgeRecipe

package/dist/src/styled-system/recipes/badge.mjs

@@ -0,0 +1,28 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const badgeFn = /* @__PURE__ */ createRecipe('badge', {
+  "variant": "default"
+}, [])
+
+const badgeVariantMap = {
+  "variant": [
+    "default",
+    "secondary",
+    "destructive",
+    "outline"
+  ]
+}
+
+const badgeVariantKeys = Object.keys(badgeVariantMap)
+
+export const badge = /* @__PURE__ */ Object.assign(badgeFn, {
+  __recipe__: true,
+  __name__: 'badge',
+  raw: (props) => props,
+  variantKeys: badgeVariantKeys,
+  variantMap: badgeVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, badgeVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/blockquote.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface BlockquoteVariant {
+  
+}
+
+type BlockquoteVariantMap = {
+  [key in keyof BlockquoteVariant]: Array<BlockquoteVariant[key]>
+}
+
+export type BlockquoteVariantProps = {
+  [key in keyof BlockquoteVariant]?: ConditionalValue<BlockquoteVariant[key]>
+}
+
+export interface BlockquoteRecipe {
+  __type: BlockquoteVariantProps
+  (props?: BlockquoteVariantProps): string
+  raw: (props?: BlockquoteVariantProps) => BlockquoteVariantProps
+  variantMap: BlockquoteVariantMap
+  variantKeys: Array<keyof BlockquoteVariant>
+  splitVariantProps<Props extends BlockquoteVariantProps>(props: Props): [BlockquoteVariantProps, Pretty<DistributiveOmit<Props, keyof BlockquoteVariantProps>>]
+}
+
+/** Typography - blockquote style */
+export declare const blockquote: BlockquoteRecipe

package/dist/src/styled-system/recipes/blockquote.mjs

@@ -0,0 +1,19 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const blockquoteFn = /* @__PURE__ */ createRecipe('blockquote', {}, [])
+
+const blockquoteVariantMap = {}
+
+const blockquoteVariantKeys = Object.keys(blockquoteVariantMap)
+
+export const blockquote = /* @__PURE__ */ Object.assign(blockquoteFn, {
+  __recipe__: true,
+  __name__: 'blockquote',
+  raw: (props) => props,
+  variantKeys: blockquoteVariantKeys,
+  variantMap: blockquoteVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, blockquoteVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/button.d.mts

@@ -0,0 +1,29 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface ButtonVariant {
+  variant: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link"
+size: "default" | "sm" | "lg" | "icon"
+}
+
+type ButtonVariantMap = {
+  [key in keyof ButtonVariant]: Array<ButtonVariant[key]>
+}
+
+export type ButtonVariantProps = {
+  [key in keyof ButtonVariant]?: ConditionalValue<ButtonVariant[key]>
+}
+
+export interface ButtonRecipe {
+  __type: ButtonVariantProps
+  (props?: ButtonVariantProps): string
+  raw: (props?: ButtonVariantProps) => ButtonVariantProps
+  variantMap: ButtonVariantMap
+  variantKeys: Array<keyof ButtonVariant>
+  splitVariantProps<Props extends ButtonVariantProps>(props: Props): [ButtonVariantProps, Pretty<DistributiveOmit<Props, keyof ButtonVariantProps>>]
+}
+
+/** Styles for the Button component */
+export declare const button: ButtonRecipe

package/dist/src/styled-system/recipes/button.mjs

@@ -0,0 +1,37 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const buttonFn = /* @__PURE__ */ createRecipe('button', {
+  "variant": "default",
+  "size": "default"
+}, [])
+
+const buttonVariantMap = {
+  "variant": [
+    "default",
+    "destructive",
+    "outline",
+    "secondary",
+    "ghost",
+    "link"
+  ],
+  "size": [
+    "default",
+    "sm",
+    "lg",
+    "icon"
+  ]
+}
+
+const buttonVariantKeys = Object.keys(buttonVariantMap)
+
+export const button = /* @__PURE__ */ Object.assign(buttonFn, {
+  __recipe__: true,
+  __name__: 'button',
+  raw: (props) => props,
+  variantKeys: buttonVariantKeys,
+  variantMap: buttonVariantMap,
+  splitVariantProps(props) {
+    return splitProps(props, buttonVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/calendar.d.mts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index.d.mts';
+import type { Pretty } from '../types/helpers.d.mts';
+import type { DistributiveOmit } from '../types/system-types.d.mts';
+
+interface CalendarVariant {
+  
+}
+
+type CalendarVariantMap = {
+  [key in keyof CalendarVariant]: Array<CalendarVariant[key]>
+}
+
+export type CalendarVariantProps = {
+  [key in keyof CalendarVariant]?: ConditionalValue<CalendarVariant[key]>
+}
+
+export interface CalendarRecipe {
+  __type: CalendarVariantProps
+  (props?: CalendarVariantProps): Pretty<Record<"root" | "months" | "month" | "caption" | "caption_label" | "nav" | "nav_button" | "nav_button_previous" | "nav_button_next" | "table" | "head_row" | "head_cell" | "row" | "cell" | "day" | "day_selected" | "day_today" | "day_outside" | "day_disabled" | "day_range_start" | "day_range_middle" | "day_range_end" | "day_hidden", string>>
+  raw: (props?: CalendarVariantProps) => CalendarVariantProps
+  variantMap: CalendarVariantMap
+  variantKeys: Array<keyof CalendarVariant>
+  splitVariantProps<Props extends CalendarVariantProps>(props: Props): [CalendarVariantProps, Pretty<DistributiveOmit<Props, keyof CalendarVariantProps>>]
+}
+
+/** Styles for the Calendar component */
+export declare const calendar: CalendarRecipe