@luxonis/depthai-pipeline-lib 1.4.8

package/dist/src/styled-system/recipes/table-caption.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 TableCaptionVariant {
+  
+}
+
+type TableCaptionVariantMap = {
+  [key in keyof TableCaptionVariant]: Array<TableCaptionVariant[key]>
+}
+
+export type TableCaptionVariantProps = {
+  [key in keyof TableCaptionVariant]?: ConditionalValue<TableCaptionVariant[key]>
+}
+
+export interface TableCaptionRecipe {
+  __type: TableCaptionVariantProps
+  (props?: TableCaptionVariantProps): string
+  raw: (props?: TableCaptionVariantProps) => TableCaptionVariantProps
+  variantMap: TableCaptionVariantMap
+  variantKeys: Array<keyof TableCaptionVariant>
+  splitVariantProps<Props extends TableCaptionVariantProps>(props: Props): [TableCaptionVariantProps, Pretty<DistributiveOmit<Props, keyof TableCaptionVariantProps>>]
+}
+
+/** Styles for the TableCaption component */
+export declare const tableCaption: TableCaptionRecipe

package/dist/src/styled-system/recipes/table-caption.mjs

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

package/dist/src/styled-system/recipes/table-cell.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 TableCellVariant {
+  
+}
+
+type TableCellVariantMap = {
+  [key in keyof TableCellVariant]: Array<TableCellVariant[key]>
+}
+
+export type TableCellVariantProps = {
+  [key in keyof TableCellVariant]?: ConditionalValue<TableCellVariant[key]>
+}
+
+export interface TableCellRecipe {
+  __type: TableCellVariantProps
+  (props?: TableCellVariantProps): string
+  raw: (props?: TableCellVariantProps) => TableCellVariantProps
+  variantMap: TableCellVariantMap
+  variantKeys: Array<keyof TableCellVariant>
+  splitVariantProps<Props extends TableCellVariantProps>(props: Props): [TableCellVariantProps, Pretty<DistributiveOmit<Props, keyof TableCellVariantProps>>]
+}
+
+/** Styles for the TableCell component */
+export declare const tableCell: TableCellRecipe

package/dist/src/styled-system/recipes/table-cell.mjs

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

package/dist/src/styled-system/recipes/table-container.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 TableContainerVariant {
+  
+}
+
+type TableContainerVariantMap = {
+  [key in keyof TableContainerVariant]: Array<TableContainerVariant[key]>
+}
+
+export type TableContainerVariantProps = {
+  [key in keyof TableContainerVariant]?: ConditionalValue<TableContainerVariant[key]>
+}
+
+export interface TableContainerRecipe {
+  __type: TableContainerVariantProps
+  (props?: TableContainerVariantProps): string
+  raw: (props?: TableContainerVariantProps) => TableContainerVariantProps
+  variantMap: TableContainerVariantMap
+  variantKeys: Array<keyof TableContainerVariant>
+  splitVariantProps<Props extends TableContainerVariantProps>(props: Props): [TableContainerVariantProps, Pretty<DistributiveOmit<Props, keyof TableContainerVariantProps>>]
+}
+
+/** Styles for the TableContainer component */
+export declare const tableContainer: TableContainerRecipe

package/dist/src/styled-system/recipes/table-container.mjs

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

package/dist/src/styled-system/recipes/table-footer.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 TableFooterVariant {
+  
+}
+
+type TableFooterVariantMap = {
+  [key in keyof TableFooterVariant]: Array<TableFooterVariant[key]>
+}
+
+export type TableFooterVariantProps = {
+  [key in keyof TableFooterVariant]?: ConditionalValue<TableFooterVariant[key]>
+}
+
+export interface TableFooterRecipe {
+  __type: TableFooterVariantProps
+  (props?: TableFooterVariantProps): string
+  raw: (props?: TableFooterVariantProps) => TableFooterVariantProps
+  variantMap: TableFooterVariantMap
+  variantKeys: Array<keyof TableFooterVariant>
+  splitVariantProps<Props extends TableFooterVariantProps>(props: Props): [TableFooterVariantProps, Pretty<DistributiveOmit<Props, keyof TableFooterVariantProps>>]
+}
+
+/** Styles for the TableFooter component */
+export declare const tableFooter: TableFooterRecipe

package/dist/src/styled-system/recipes/table-footer.mjs

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

package/dist/src/styled-system/recipes/table-head.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 TableHeadVariant {
+  
+}
+
+type TableHeadVariantMap = {
+  [key in keyof TableHeadVariant]: Array<TableHeadVariant[key]>
+}
+
+export type TableHeadVariantProps = {
+  [key in keyof TableHeadVariant]?: ConditionalValue<TableHeadVariant[key]>
+}
+
+export interface TableHeadRecipe {
+  __type: TableHeadVariantProps
+  (props?: TableHeadVariantProps): string
+  raw: (props?: TableHeadVariantProps) => TableHeadVariantProps
+  variantMap: TableHeadVariantMap
+  variantKeys: Array<keyof TableHeadVariant>
+  splitVariantProps<Props extends TableHeadVariantProps>(props: Props): [TableHeadVariantProps, Pretty<DistributiveOmit<Props, keyof TableHeadVariantProps>>]
+}
+
+/** Styles for the TableHead component */
+export declare const tableHead: TableHeadRecipe

package/dist/src/styled-system/recipes/table-head.mjs

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

package/dist/src/styled-system/recipes/table-header.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 TableHeaderVariant {
+  
+}
+
+type TableHeaderVariantMap = {
+  [key in keyof TableHeaderVariant]: Array<TableHeaderVariant[key]>
+}
+
+export type TableHeaderVariantProps = {
+  [key in keyof TableHeaderVariant]?: ConditionalValue<TableHeaderVariant[key]>
+}
+
+export interface TableHeaderRecipe {
+  __type: TableHeaderVariantProps
+  (props?: TableHeaderVariantProps): string
+  raw: (props?: TableHeaderVariantProps) => TableHeaderVariantProps
+  variantMap: TableHeaderVariantMap
+  variantKeys: Array<keyof TableHeaderVariant>
+  splitVariantProps<Props extends TableHeaderVariantProps>(props: Props): [TableHeaderVariantProps, Pretty<DistributiveOmit<Props, keyof TableHeaderVariantProps>>]
+}
+
+/** Styles for the TableHeader component */
+export declare const tableHeader: TableHeaderRecipe

package/dist/src/styled-system/recipes/table-header.mjs

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

package/dist/src/styled-system/recipes/table-row.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 TableRowVariant {
+  
+}
+
+type TableRowVariantMap = {
+  [key in keyof TableRowVariant]: Array<TableRowVariant[key]>
+}
+
+export type TableRowVariantProps = {
+  [key in keyof TableRowVariant]?: ConditionalValue<TableRowVariant[key]>
+}
+
+export interface TableRowRecipe {
+  __type: TableRowVariantProps
+  (props?: TableRowVariantProps): string
+  raw: (props?: TableRowVariantProps) => TableRowVariantProps
+  variantMap: TableRowVariantMap
+  variantKeys: Array<keyof TableRowVariant>
+  splitVariantProps<Props extends TableRowVariantProps>(props: Props): [TableRowVariantProps, Pretty<DistributiveOmit<Props, keyof TableRowVariantProps>>]
+}
+
+/** Styles for the TableRow component */
+export declare const tableRow: TableRowRecipe

package/dist/src/styled-system/recipes/table-row.mjs

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

package/dist/src/styled-system/recipes/table.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 TableVariant {
+  
+}
+
+type TableVariantMap = {
+  [key in keyof TableVariant]: Array<TableVariant[key]>
+}
+
+export type TableVariantProps = {
+  [key in keyof TableVariant]?: ConditionalValue<TableVariant[key]>
+}
+
+export interface TableRecipe {
+  __type: TableVariantProps
+  (props?: TableVariantProps): string
+  raw: (props?: TableVariantProps) => TableVariantProps
+  variantMap: TableVariantMap
+  variantKeys: Array<keyof TableVariant>
+  splitVariantProps<Props extends TableVariantProps>(props: Props): [TableVariantProps, Pretty<DistributiveOmit<Props, keyof TableVariantProps>>]
+}
+
+/** Styles for the Table component */
+export declare const table: TableRecipe

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

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

package/dist/src/styled-system/recipes/tabs.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 TabsVariant {
+  
+}
+
+type TabsVariantMap = {
+  [key in keyof TabsVariant]: Array<TabsVariant[key]>
+}
+
+export type TabsVariantProps = {
+  [key in keyof TabsVariant]?: ConditionalValue<TabsVariant[key]>
+}
+
+export interface TabsRecipe {
+  __type: TabsVariantProps
+  (props?: TabsVariantProps): Pretty<Record<"root" | "list" | "trigger" | "content", string>>
+  raw: (props?: TabsVariantProps) => TabsVariantProps
+  variantMap: TabsVariantMap
+  variantKeys: Array<keyof TabsVariant>
+  splitVariantProps<Props extends TabsVariantProps>(props: Props): [TabsVariantProps, Pretty<DistributiveOmit<Props, keyof TabsVariantProps>>]
+}
+
+/** Styles for the Tabs component */
+export declare const tabs: TabsRecipe

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

@@ -0,0 +1,42 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tabsDefaultVariants = {}
+const tabsCompoundVariants = []
+
+const tabsSlotNames = [
+  [
+    "root",
+    "tabs__root"
+  ],
+  [
+    "list",
+    "tabs__list"
+  ],
+  [
+    "trigger",
+    "tabs__trigger"
+  ],
+  [
+    "content",
+    "tabs__content"
+  ]
+]
+const tabsSlotFns = /* @__PURE__ */ tabsSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tabsDefaultVariants, getSlotCompoundVariant(tabsCompoundVariants, slotName))])
+
+const tabsFn = (props = {}) => {
+  return Object.fromEntries(tabsSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const tabsVariantKeys = []
+
+export const tabs = /* @__PURE__ */ Object.assign(tabsFn, {
+  __recipe__: false,
+  __name__: 'tabs',
+  raw: (props) => props,
+  variantKeys: tabsVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tabsVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/textarea.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 TextareaVariant {
+  
+}
+
+type TextareaVariantMap = {
+  [key in keyof TextareaVariant]: Array<TextareaVariant[key]>
+}
+
+export type TextareaVariantProps = {
+  [key in keyof TextareaVariant]?: ConditionalValue<TextareaVariant[key]>
+}
+
+export interface TextareaRecipe {
+  __type: TextareaVariantProps
+  (props?: TextareaVariantProps): string
+  raw: (props?: TextareaVariantProps) => TextareaVariantProps
+  variantMap: TextareaVariantMap
+  variantKeys: Array<keyof TextareaVariant>
+  splitVariantProps<Props extends TextareaVariantProps>(props: Props): [TextareaVariantProps, Pretty<DistributiveOmit<Props, keyof TextareaVariantProps>>]
+}
+
+/** Styles for the Textarea component */
+export declare const textarea: TextareaRecipe

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

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

package/dist/src/styled-system/recipes/toast-viewport.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 ToastViewportVariant {
+  
+}
+
+type ToastViewportVariantMap = {
+  [key in keyof ToastViewportVariant]: Array<ToastViewportVariant[key]>
+}
+
+export type ToastViewportVariantProps = {
+  [key in keyof ToastViewportVariant]?: ConditionalValue<ToastViewportVariant[key]>
+}
+
+export interface ToastViewportRecipe {
+  __type: ToastViewportVariantProps
+  (props?: ToastViewportVariantProps): string
+  raw: (props?: ToastViewportVariantProps) => ToastViewportVariantProps
+  variantMap: ToastViewportVariantMap
+  variantKeys: Array<keyof ToastViewportVariant>
+  splitVariantProps<Props extends ToastViewportVariantProps>(props: Props): [ToastViewportVariantProps, Pretty<DistributiveOmit<Props, keyof ToastViewportVariantProps>>]
+}
+
+/** Styles for the ToastViewport component */
+export declare const toastViewport: ToastViewportRecipe

package/dist/src/styled-system/recipes/toast-viewport.mjs

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

package/dist/src/styled-system/recipes/toast.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 ToastVariant {
+  variant: "default" | "destructive"
+}
+
+type ToastVariantMap = {
+  [key in keyof ToastVariant]: Array<ToastVariant[key]>
+}
+
+export type ToastVariantProps = {
+  [key in keyof ToastVariant]?: ConditionalValue<ToastVariant[key]>
+}
+
+export interface ToastRecipe {
+  __type: ToastVariantProps
+  (props?: ToastVariantProps): Pretty<Record<"root" | "viewport" | "action" | "close" | "title" | "description", string>>
+  raw: (props?: ToastVariantProps) => ToastVariantProps
+  variantMap: ToastVariantMap
+  variantKeys: Array<keyof ToastVariant>
+  splitVariantProps<Props extends ToastVariantProps>(props: Props): [ToastVariantProps, Pretty<DistributiveOmit<Props, keyof ToastVariantProps>>]
+}
+
+/** Styles for the Toast component */
+export declare const toast: ToastRecipe

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

@@ -0,0 +1,59 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const toastDefaultVariants = {
+  "variant": "default"
+}
+const toastCompoundVariants = []
+
+const toastSlotNames = [
+  [
+    "root",
+    "toast__root"
+  ],
+  [
+    "viewport",
+    "toast__viewport"
+  ],
+  [
+    "action",
+    "toast__action"
+  ],
+  [
+    "close",
+    "toast__close"
+  ],
+  [
+    "title",
+    "toast__title"
+  ],
+  [
+    "description",
+    "toast__description"
+  ]
+]
+const toastSlotFns = /* @__PURE__ */ toastSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, toastDefaultVariants, getSlotCompoundVariant(toastCompoundVariants, slotName))])
+
+const toastFn = (props = {}) => {
+  return Object.fromEntries(toastSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const toastVariantKeys = [
+  "variant"
+]
+
+export const toast = /* @__PURE__ */ Object.assign(toastFn, {
+  __recipe__: false,
+  __name__: 'toast',
+  raw: (props) => props,
+  variantKeys: toastVariantKeys,
+  variantMap: {
+  "variant": [
+    "default",
+    "destructive"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, toastVariantKeys)
+  },
+})