@luxonis/depthai-pipeline-lib 1.4.8

package/dist/src/styled-system/recipes/large.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 LargeVariant {
+  
+}
+
+type LargeVariantMap = {
+  [key in keyof LargeVariant]: Array<LargeVariant[key]>
+}
+
+export type LargeVariantProps = {
+  [key in keyof LargeVariant]?: ConditionalValue<LargeVariant[key]>
+}
+
+export interface LargeRecipe {
+  __type: LargeVariantProps
+  (props?: LargeVariantProps): string
+  raw: (props?: LargeVariantProps) => LargeVariantProps
+  variantMap: LargeVariantMap
+  variantKeys: Array<keyof LargeVariant>
+  splitVariantProps<Props extends LargeVariantProps>(props: Props): [LargeVariantProps, Pretty<DistributiveOmit<Props, keyof LargeVariantProps>>]
+}
+
+/** Typography - Large style */
+export declare const large: LargeRecipe

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

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

package/dist/src/styled-system/recipes/lead.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 LeadVariant {
+  
+}
+
+type LeadVariantMap = {
+  [key in keyof LeadVariant]: Array<LeadVariant[key]>
+}
+
+export type LeadVariantProps = {
+  [key in keyof LeadVariant]?: ConditionalValue<LeadVariant[key]>
+}
+
+export interface LeadRecipe {
+  __type: LeadVariantProps
+  (props?: LeadVariantProps): string
+  raw: (props?: LeadVariantProps) => LeadVariantProps
+  variantMap: LeadVariantMap
+  variantKeys: Array<keyof LeadVariant>
+  splitVariantProps<Props extends LeadVariantProps>(props: Props): [LeadVariantProps, Pretty<DistributiveOmit<Props, keyof LeadVariantProps>>]
+}
+
+/** Typography - Lead style */
+export declare const lead: LeadRecipe

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

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

package/dist/src/styled-system/recipes/link.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 LinkVariant {
+  
+}
+
+type LinkVariantMap = {
+  [key in keyof LinkVariant]: Array<LinkVariant[key]>
+}
+
+export type LinkVariantProps = {
+  [key in keyof LinkVariant]?: ConditionalValue<LinkVariant[key]>
+}
+
+export interface LinkRecipe {
+  __type: LinkVariantProps
+  (props?: LinkVariantProps): string
+  raw: (props?: LinkVariantProps) => LinkVariantProps
+  variantMap: LinkVariantMap
+  variantKeys: Array<keyof LinkVariant>
+  splitVariantProps<Props extends LinkVariantProps>(props: Props): [LinkVariantProps, Pretty<DistributiveOmit<Props, keyof LinkVariantProps>>]
+}
+
+/** Typography - Link style */
+export declare const link: LinkRecipe

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

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

package/dist/src/styled-system/recipes/list.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 ListVariant {
+  
+}
+
+type ListVariantMap = {
+  [key in keyof ListVariant]: Array<ListVariant[key]>
+}
+
+export type ListVariantProps = {
+  [key in keyof ListVariant]?: ConditionalValue<ListVariant[key]>
+}
+
+export interface ListRecipe {
+  __type: ListVariantProps
+  (props?: ListVariantProps): string
+  raw: (props?: ListVariantProps) => ListVariantProps
+  variantMap: ListVariantMap
+  variantKeys: Array<keyof ListVariant>
+  splitVariantProps<Props extends ListVariantProps>(props: Props): [ListVariantProps, Pretty<DistributiveOmit<Props, keyof ListVariantProps>>]
+}
+
+/** Typography - list style */
+export declare const list: ListRecipe

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

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

package/dist/src/styled-system/recipes/menubar.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 MenubarVariant {
+  
+}
+
+type MenubarVariantMap = {
+  [key in keyof MenubarVariant]: Array<MenubarVariant[key]>
+}
+
+export type MenubarVariantProps = {
+  [key in keyof MenubarVariant]?: ConditionalValue<MenubarVariant[key]>
+}
+
+export interface MenubarRecipe {
+  __type: MenubarVariantProps
+  (props?: MenubarVariantProps): Pretty<Record<"root" | "menu" | "group" | "portal" | "sub" | "radioGroup" | "trigger" | "subTrigger" | "subContent" | "content" | "item" | "checkboxItem" | "radioItem" | "itemIndicator" | "label" | "separator" | "shortcut", string>>
+  raw: (props?: MenubarVariantProps) => MenubarVariantProps
+  variantMap: MenubarVariantMap
+  variantKeys: Array<keyof MenubarVariant>
+  splitVariantProps<Props extends MenubarVariantProps>(props: Props): [MenubarVariantProps, Pretty<DistributiveOmit<Props, keyof MenubarVariantProps>>]
+}
+
+/** Styles for the Menubar component */
+export declare const menubar: MenubarRecipe

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

@@ -0,0 +1,94 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const menubarDefaultVariants = {}
+const menubarCompoundVariants = []
+
+const menubarSlotNames = [
+  [
+    "root",
+    "menubar__root"
+  ],
+  [
+    "menu",
+    "menubar__menu"
+  ],
+  [
+    "group",
+    "menubar__group"
+  ],
+  [
+    "portal",
+    "menubar__portal"
+  ],
+  [
+    "sub",
+    "menubar__sub"
+  ],
+  [
+    "radioGroup",
+    "menubar__radioGroup"
+  ],
+  [
+    "trigger",
+    "menubar__trigger"
+  ],
+  [
+    "subTrigger",
+    "menubar__subTrigger"
+  ],
+  [
+    "subContent",
+    "menubar__subContent"
+  ],
+  [
+    "content",
+    "menubar__content"
+  ],
+  [
+    "item",
+    "menubar__item"
+  ],
+  [
+    "checkboxItem",
+    "menubar__checkboxItem"
+  ],
+  [
+    "radioItem",
+    "menubar__radioItem"
+  ],
+  [
+    "itemIndicator",
+    "menubar__itemIndicator"
+  ],
+  [
+    "label",
+    "menubar__label"
+  ],
+  [
+    "separator",
+    "menubar__separator"
+  ],
+  [
+    "shortcut",
+    "menubar__shortcut"
+  ]
+]
+const menubarSlotFns = /* @__PURE__ */ menubarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, menubarDefaultVariants, getSlotCompoundVariant(menubarCompoundVariants, slotName))])
+
+const menubarFn = (props = {}) => {
+  return Object.fromEntries(menubarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const menubarVariantKeys = []
+
+export const menubar = /* @__PURE__ */ Object.assign(menubarFn, {
+  __recipe__: false,
+  __name__: 'menubar',
+  raw: (props) => props,
+  variantKeys: menubarVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, menubarVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/muted.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 MutedVariant {
+  
+}
+
+type MutedVariantMap = {
+  [key in keyof MutedVariant]: Array<MutedVariant[key]>
+}
+
+export type MutedVariantProps = {
+  [key in keyof MutedVariant]?: ConditionalValue<MutedVariant[key]>
+}
+
+export interface MutedRecipe {
+  __type: MutedVariantProps
+  (props?: MutedVariantProps): string
+  raw: (props?: MutedVariantProps) => MutedVariantProps
+  variantMap: MutedVariantMap
+  variantKeys: Array<keyof MutedVariant>
+  splitVariantProps<Props extends MutedVariantProps>(props: Props): [MutedVariantProps, Pretty<DistributiveOmit<Props, keyof MutedVariantProps>>]
+}
+
+/** Typography - Muted style */
+export declare const muted: MutedRecipe

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

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

package/dist/src/styled-system/recipes/navigation-menu.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 NavigationMenuVariant {
+  
+}
+
+type NavigationMenuVariantMap = {
+  [key in keyof NavigationMenuVariant]: Array<NavigationMenuVariant[key]>
+}
+
+export type NavigationMenuVariantProps = {
+  [key in keyof NavigationMenuVariant]?: ConditionalValue<NavigationMenuVariant[key]>
+}
+
+export interface NavigationMenuRecipe {
+  __type: NavigationMenuVariantProps
+  (props?: NavigationMenuVariantProps): Pretty<Record<"root" | "list" | "item" | "trigger" | "content" | "link" | "viewportWrapper" | "viewport" | "indicator", string>>
+  raw: (props?: NavigationMenuVariantProps) => NavigationMenuVariantProps
+  variantMap: NavigationMenuVariantMap
+  variantKeys: Array<keyof NavigationMenuVariant>
+  splitVariantProps<Props extends NavigationMenuVariantProps>(props: Props): [NavigationMenuVariantProps, Pretty<DistributiveOmit<Props, keyof NavigationMenuVariantProps>>]
+}
+
+/** Styles for the NavigationMenu component */
+export declare const navigationMenu: NavigationMenuRecipe

package/dist/src/styled-system/recipes/navigation-menu.mjs

@@ -0,0 +1,62 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const navigationMenuDefaultVariants = {}
+const navigationMenuCompoundVariants = []
+
+const navigationMenuSlotNames = [
+  [
+    "root",
+    "navigationMenu__root"
+  ],
+  [
+    "list",
+    "navigationMenu__list"
+  ],
+  [
+    "item",
+    "navigationMenu__item"
+  ],
+  [
+    "trigger",
+    "navigationMenu__trigger"
+  ],
+  [
+    "content",
+    "navigationMenu__content"
+  ],
+  [
+    "link",
+    "navigationMenu__link"
+  ],
+  [
+    "viewportWrapper",
+    "navigationMenu__viewportWrapper"
+  ],
+  [
+    "viewport",
+    "navigationMenu__viewport"
+  ],
+  [
+    "indicator",
+    "navigationMenu__indicator"
+  ]
+]
+const navigationMenuSlotFns = /* @__PURE__ */ navigationMenuSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, navigationMenuDefaultVariants, getSlotCompoundVariant(navigationMenuCompoundVariants, slotName))])
+
+const navigationMenuFn = (props = {}) => {
+  return Object.fromEntries(navigationMenuSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const navigationMenuVariantKeys = []
+
+export const navigationMenu = /* @__PURE__ */ Object.assign(navigationMenuFn, {
+  __recipe__: false,
+  __name__: 'navigationMenu',
+  raw: (props) => props,
+  variantKeys: navigationMenuVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, navigationMenuVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/p.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 PVariant {
+  
+}
+
+type PVariantMap = {
+  [key in keyof PVariant]: Array<PVariant[key]>
+}
+
+export type PVariantProps = {
+  [key in keyof PVariant]?: ConditionalValue<PVariant[key]>
+}
+
+export interface PRecipe {
+  __type: PVariantProps
+  (props?: PVariantProps): string
+  raw: (props?: PVariantProps) => PVariantProps
+  variantMap: PVariantMap
+  variantKeys: Array<keyof PVariant>
+  splitVariantProps<Props extends PVariantProps>(props: Props): [PVariantProps, Pretty<DistributiveOmit<Props, keyof PVariantProps>>]
+}
+
+/** Typography - p style */
+export declare const p: PRecipe

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

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

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

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

@@ -0,0 +1,42 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const popoverDefaultVariants = {}
+const popoverCompoundVariants = []
+
+const popoverSlotNames = [
+  [
+    "root",
+    "popover__root"
+  ],
+  [
+    "trigger",
+    "popover__trigger"
+  ],
+  [
+    "portal",
+    "popover__portal"
+  ],
+  [
+    "content",
+    "popover__content"
+  ]
+]
+const popoverSlotFns = /* @__PURE__ */ popoverSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, popoverDefaultVariants, getSlotCompoundVariant(popoverCompoundVariants, slotName))])
+
+const popoverFn = (props = {}) => {
+  return Object.fromEntries(popoverSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const popoverVariantKeys = []
+
+export const popover = /* @__PURE__ */ Object.assign(popoverFn, {
+  __recipe__: false,
+  __name__: 'popover',
+  raw: (props) => props,
+  variantKeys: popoverVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, popoverVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/progress.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 ProgressVariant {
+  
+}
+
+type ProgressVariantMap = {
+  [key in keyof ProgressVariant]: Array<ProgressVariant[key]>
+}
+
+export type ProgressVariantProps = {
+  [key in keyof ProgressVariant]?: ConditionalValue<ProgressVariant[key]>
+}
+
+export interface ProgressRecipe {
+  __type: ProgressVariantProps
+  (props?: ProgressVariantProps): Pretty<Record<"root" | "indicator", string>>
+  raw: (props?: ProgressVariantProps) => ProgressVariantProps
+  variantMap: ProgressVariantMap
+  variantKeys: Array<keyof ProgressVariant>
+  splitVariantProps<Props extends ProgressVariantProps>(props: Props): [ProgressVariantProps, Pretty<DistributiveOmit<Props, keyof ProgressVariantProps>>]
+}
+
+/** Styles for the Progress component */
+export declare const progress: ProgressRecipe

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

@@ -0,0 +1,34 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const progressDefaultVariants = {}
+const progressCompoundVariants = []
+
+const progressSlotNames = [
+  [
+    "root",
+    "progress__root"
+  ],
+  [
+    "indicator",
+    "progress__indicator"
+  ]
+]
+const progressSlotFns = /* @__PURE__ */ progressSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, progressDefaultVariants, getSlotCompoundVariant(progressCompoundVariants, slotName))])
+
+const progressFn = (props = {}) => {
+  return Object.fromEntries(progressSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const progressVariantKeys = []
+
+export const progress = /* @__PURE__ */ Object.assign(progressFn, {
+  __recipe__: false,
+  __name__: 'progress',
+  raw: (props) => props,
+  variantKeys: progressVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, progressVariantKeys)
+  },
+})

package/dist/src/styled-system/recipes/radio-group.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 RadioGroupVariant {
+  
+}
+
+type RadioGroupVariantMap = {
+  [key in keyof RadioGroupVariant]: Array<RadioGroupVariant[key]>
+}
+
+export type RadioGroupVariantProps = {
+  [key in keyof RadioGroupVariant]?: ConditionalValue<RadioGroupVariant[key]>
+}
+
+export interface RadioGroupRecipe {
+  __type: RadioGroupVariantProps
+  (props?: RadioGroupVariantProps): Pretty<Record<"root" | "item" | "indicator" | "icon", string>>
+  raw: (props?: RadioGroupVariantProps) => RadioGroupVariantProps
+  variantMap: RadioGroupVariantMap
+  variantKeys: Array<keyof RadioGroupVariant>
+  splitVariantProps<Props extends RadioGroupVariantProps>(props: Props): [RadioGroupVariantProps, Pretty<DistributiveOmit<Props, keyof RadioGroupVariantProps>>]
+}
+
+/** Styles for the RadioGroup component */
+export declare const radioGroup: RadioGroupRecipe