@integration-app/react 2.0.3-beta.0 → 2.0.3-beta.1

package/dist/types/styled-system/patterns/circle.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface CircleProperties {
+   size?: SystemProperties["width"]
+}
+
+
+interface CircleStyles extends CircleProperties, DistributiveOmit<SystemStyleObject, keyof CircleProperties > {}
+
+interface CirclePatternFn {
+  (styles?: CircleStyles): string
+  raw: (styles?: CircleStyles) => SystemStyleObject
+}
+
+
+export declare const circle: CirclePatternFn;

package/dist/types/styled-system/patterns/container.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface ContainerProperties {
+   
+}
+
+
+interface ContainerStyles extends ContainerProperties, DistributiveOmit<SystemStyleObject, keyof ContainerProperties > {}
+
+interface ContainerPatternFn {
+  (styles?: ContainerStyles): string
+  raw: (styles?: ContainerStyles) => SystemStyleObject
+}
+
+
+export declare const container: ContainerPatternFn;

package/dist/types/styled-system/patterns/cq.d.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface CqProperties {
+   name?: ConditionalValue<Tokens["containerNames"] | Properties["containerName"]>
+	type?: SystemProperties["containerType"]
+}
+
+
+interface CqStyles extends CqProperties, DistributiveOmit<SystemStyleObject, keyof CqProperties > {}
+
+interface CqPatternFn {
+  (styles?: CqStyles): string
+  raw: (styles?: CqStyles) => SystemStyleObject
+}
+
+
+export declare const cq: CqPatternFn;

package/dist/types/styled-system/patterns/divider.d.ts

@@ -0,0 +1,23 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface DividerProperties {
+   orientation?: ConditionalValue<"horizontal" | "vertical">
+	thickness?: ConditionalValue<Tokens["sizes"] | Properties["borderWidth"]>
+	color?: ConditionalValue<Tokens["colors"] | Properties["borderColor"]>
+}
+
+
+interface DividerStyles extends DividerProperties, DistributiveOmit<SystemStyleObject, keyof DividerProperties > {}
+
+interface DividerPatternFn {
+  (styles?: DividerStyles): string
+  raw: (styles?: DividerStyles) => SystemStyleObject
+}
+
+
+export declare const divider: DividerPatternFn;

package/dist/types/styled-system/patterns/flex.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface FlexProperties {
+   align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["justifyContent"]
+	direction?: SystemProperties["flexDirection"]
+	wrap?: SystemProperties["flexWrap"]
+	basis?: SystemProperties["flexBasis"]
+	grow?: SystemProperties["flexGrow"]
+	shrink?: SystemProperties["flexShrink"]
+}
+
+
+interface FlexStyles extends FlexProperties, DistributiveOmit<SystemStyleObject, keyof FlexProperties > {}
+
+interface FlexPatternFn {
+  (styles?: FlexStyles): string
+  raw: (styles?: FlexStyles) => SystemStyleObject
+}
+
+
+export declare const flex: FlexPatternFn;

package/dist/types/styled-system/patterns/float.d.ts

@@ -0,0 +1,24 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface FloatProperties {
+   offsetX?: ConditionalValue<Tokens["spacing"] | Properties["left"]>
+	offsetY?: ConditionalValue<Tokens["spacing"] | Properties["top"]>
+	offset?: ConditionalValue<Tokens["spacing"] | Properties["top"]>
+	placement?: ConditionalValue<"bottom-end" | "bottom-start" | "top-end" | "top-start" | "bottom-center" | "top-center" | "middle-center" | "middle-end" | "middle-start">
+}
+
+
+interface FloatStyles extends FloatProperties, DistributiveOmit<SystemStyleObject, keyof FloatProperties > {}
+
+interface FloatPatternFn {
+  (styles?: FloatStyles): string
+  raw: (styles?: FloatStyles) => SystemStyleObject
+}
+
+
+export declare const float: FloatPatternFn;

package/dist/types/styled-system/patterns/grid-item.d.ts

@@ -0,0 +1,26 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface GridItemProperties {
+   colSpan?: ConditionalValue<number>
+	rowSpan?: ConditionalValue<number>
+	colStart?: ConditionalValue<number>
+	rowStart?: ConditionalValue<number>
+	colEnd?: ConditionalValue<number>
+	rowEnd?: ConditionalValue<number>
+}
+
+
+interface GridItemStyles extends GridItemProperties, DistributiveOmit<SystemStyleObject, keyof GridItemProperties > {}
+
+interface GridItemPatternFn {
+  (styles?: GridItemStyles): string
+  raw: (styles?: GridItemStyles) => SystemStyleObject
+}
+
+
+export declare const gridItem: GridItemPatternFn;

package/dist/types/styled-system/patterns/grid.d.ts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface GridProperties {
+   gap?: SystemProperties["gap"]
+	columnGap?: SystemProperties["gap"]
+	rowGap?: SystemProperties["gap"]
+	columns?: ConditionalValue<number>
+	minChildWidth?: ConditionalValue<Tokens["sizes"] | Properties["width"]>
+}
+
+
+interface GridStyles extends GridProperties, DistributiveOmit<SystemStyleObject, keyof GridProperties > {}
+
+interface GridPatternFn {
+  (styles?: GridStyles): string
+  raw: (styles?: GridStyles) => SystemStyleObject
+}
+
+
+export declare const grid: GridPatternFn;

package/dist/types/styled-system/patterns/hstack.d.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface HstackProperties {
+   justify?: SystemProperties["justifyContent"]
+	gap?: SystemProperties["gap"]
+}
+
+
+interface HstackStyles extends HstackProperties, DistributiveOmit<SystemStyleObject, keyof HstackProperties > {}
+
+interface HstackPatternFn {
+  (styles?: HstackStyles): string
+  raw: (styles?: HstackStyles) => SystemStyleObject
+}
+
+
+export declare const hstack: HstackPatternFn;

package/dist/types/styled-system/patterns/index.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+export * from './box';
+export * from './flex';
+export * from './stack';
+export * from './vstack';
+export * from './hstack';
+export * from './spacer';
+export * from './square';
+export * from './circle';
+export * from './center';
+export * from './link-overlay';
+export * from './aspect-ratio';
+export * from './grid';
+export * from './grid-item';
+export * from './wrap';
+export * from './container';
+export * from './divider';
+export * from './float';
+export * from './bleed';
+export * from './visually-hidden';
+export * from './cq';

package/dist/types/styled-system/patterns/link-overlay.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface LinkOverlayProperties {
+   
+}
+
+
+interface LinkOverlayStyles extends LinkOverlayProperties, DistributiveOmit<SystemStyleObject, keyof LinkOverlayProperties > {}
+
+interface LinkOverlayPatternFn {
+  (styles?: LinkOverlayStyles): string
+  raw: (styles?: LinkOverlayStyles) => SystemStyleObject
+}
+
+
+export declare const linkOverlay: LinkOverlayPatternFn;

package/dist/types/styled-system/patterns/spacer.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface SpacerProperties {
+   size?: ConditionalValue<Tokens["spacing"]>
+}
+
+
+interface SpacerStyles extends SpacerProperties, DistributiveOmit<SystemStyleObject, keyof SpacerProperties > {}
+
+interface SpacerPatternFn {
+  (styles?: SpacerStyles): string
+  raw: (styles?: SpacerStyles) => SystemStyleObject
+}
+
+
+export declare const spacer: SpacerPatternFn;

package/dist/types/styled-system/patterns/square.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface SquareProperties {
+   size?: SystemProperties["width"]
+}
+
+
+interface SquareStyles extends SquareProperties, DistributiveOmit<SystemStyleObject, keyof SquareProperties > {}
+
+interface SquarePatternFn {
+  (styles?: SquareStyles): string
+  raw: (styles?: SquareStyles) => SystemStyleObject
+}
+
+
+export declare const square: SquarePatternFn;

package/dist/types/styled-system/patterns/stack.d.ts

@@ -0,0 +1,24 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface StackProperties {
+   align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["justifyContent"]
+	direction?: SystemProperties["flexDirection"]
+	gap?: SystemProperties["gap"]
+}
+
+
+interface StackStyles extends StackProperties, DistributiveOmit<SystemStyleObject, keyof StackProperties > {}
+
+interface StackPatternFn {
+  (styles?: StackStyles): string
+  raw: (styles?: StackStyles) => SystemStyleObject
+}
+
+
+export declare const stack: StackPatternFn;

package/dist/types/styled-system/patterns/visually-hidden.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface VisuallyHiddenProperties {
+   
+}
+
+
+interface VisuallyHiddenStyles extends VisuallyHiddenProperties, DistributiveOmit<SystemStyleObject, keyof VisuallyHiddenProperties > {}
+
+interface VisuallyHiddenPatternFn {
+  (styles?: VisuallyHiddenStyles): string
+  raw: (styles?: VisuallyHiddenStyles) => SystemStyleObject
+}
+
+
+export declare const visuallyHidden: VisuallyHiddenPatternFn;

package/dist/types/styled-system/patterns/vstack.d.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface VstackProperties {
+   justify?: SystemProperties["justifyContent"]
+	gap?: SystemProperties["gap"]
+}
+
+
+interface VstackStyles extends VstackProperties, DistributiveOmit<SystemStyleObject, keyof VstackProperties > {}
+
+interface VstackPatternFn {
+  (styles?: VstackStyles): string
+  raw: (styles?: VstackStyles) => SystemStyleObject
+}
+
+
+export declare const vstack: VstackPatternFn;

package/dist/types/styled-system/patterns/wrap.d.ts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface WrapProperties {
+   gap?: SystemProperties["gap"]
+	rowGap?: SystemProperties["gap"]
+	columnGap?: SystemProperties["gap"]
+	align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["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/types/styled-system/recipes/accordion.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AccordionVariant {
+  /**
+ * @default "md"
+ */
+size: "md"
+}
+
+type AccordionVariantMap = {
+  [key in keyof AccordionVariant]: Array<AccordionVariant[key]>
+}
+
+export type AccordionVariantProps = {
+  [key in keyof AccordionVariant]?: ConditionalValue<AccordionVariant[key]> | undefined
+}
+
+export interface AccordionRecipe {
+  __type: AccordionVariantProps
+  (props?: AccordionVariantProps): Pretty<Record<"root" | "item" | "itemTrigger" | "itemContent" | "itemIndicator", string>>
+  raw: (props?: AccordionVariantProps) => AccordionVariantProps
+  variantMap: AccordionVariantMap
+  variantKeys: Array<keyof AccordionVariant>
+  splitVariantProps<Props extends AccordionVariantProps>(props: Props): [AccordionVariantProps, Pretty<DistributiveOmit<Props, keyof AccordionVariantProps>>]
+  getVariantProps: (props?: AccordionVariantProps) => AccordionVariantProps
+}
+
+
+export declare const accordion: AccordionRecipe

package/dist/types/styled-system/recipes/alert.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AlertVariant {
+  
+}
+
+type AlertVariantMap = {
+  [key in keyof AlertVariant]: Array<AlertVariant[key]>
+}
+
+export type AlertVariantProps = {
+  [key in keyof AlertVariant]?: ConditionalValue<AlertVariant[key]> | undefined
+}
+
+export interface AlertRecipe {
+  __type: AlertVariantProps
+  (props?: AlertVariantProps): Pretty<Record<"root" | "content" | "description" | "icon" | "title", string>>
+  raw: (props?: AlertVariantProps) => AlertVariantProps
+  variantMap: AlertVariantMap
+  variantKeys: Array<keyof AlertVariant>
+  splitVariantProps<Props extends AlertVariantProps>(props: Props): [AlertVariantProps, Pretty<DistributiveOmit<Props, keyof AlertVariantProps>>]
+  getVariantProps: (props?: AlertVariantProps) => AlertVariantProps
+}
+
+
+export declare const alert: AlertRecipe

package/dist/types/styled-system/recipes/avatar.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AvatarVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+}
+
+type AvatarVariantMap = {
+  [key in keyof AvatarVariant]: Array<AvatarVariant[key]>
+}
+
+export type AvatarVariantProps = {
+  [key in keyof AvatarVariant]?: ConditionalValue<AvatarVariant[key]> | undefined
+}
+
+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>>]
+  getVariantProps: (props?: AvatarVariantProps) => AvatarVariantProps
+}
+
+
+export declare const avatar: AvatarRecipe

package/dist/types/styled-system/recipes/badge.d.ts

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface BadgeVariant {
+  /**
+ * @default "subtle"
+ */
+variant: "solid" | "subtle" | "outline"
+/**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type BadgeVariantMap = {
+  [key in keyof BadgeVariant]: Array<BadgeVariant[key]>
+}
+
+export type BadgeVariantProps = {
+  [key in keyof BadgeVariant]?: ConditionalValue<BadgeVariant[key]> | undefined
+}
+
+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>>]
+  getVariantProps: (props?: BadgeVariantProps) => BadgeVariantProps
+}
+
+
+export declare const badge: BadgeRecipe

package/dist/types/styled-system/recipes/button.d.ts

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ButtonVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid" | "outline" | "ghost" | "link" | "subtle"
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+}
+
+type ButtonVariantMap = {
+  [key in keyof ButtonVariant]: Array<ButtonVariant[key]>
+}
+
+export type ButtonVariantProps = {
+  [key in keyof ButtonVariant]?: ConditionalValue<ButtonVariant[key]> | undefined
+}
+
+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>>]
+  getVariantProps: (props?: ButtonVariantProps) => ButtonVariantProps
+}
+
+
+export declare const button: ButtonRecipe

package/dist/types/styled-system/recipes/card.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CardVariant {
+  
+}
+
+type CardVariantMap = {
+  [key in keyof CardVariant]: Array<CardVariant[key]>
+}
+
+export type CardVariantProps = {
+  [key in keyof CardVariant]?: ConditionalValue<CardVariant[key]> | undefined
+}
+
+export interface CardRecipe {
+  __type: CardVariantProps
+  (props?: CardVariantProps): Pretty<Record<"root" | "header" | "body" | "footer" | "title" | "description", string>>
+  raw: (props?: CardVariantProps) => CardVariantProps
+  variantMap: CardVariantMap
+  variantKeys: Array<keyof CardVariant>
+  splitVariantProps<Props extends CardVariantProps>(props: Props): [CardVariantProps, Pretty<DistributiveOmit<Props, keyof CardVariantProps>>]
+  getVariantProps: (props?: CardVariantProps) => CardVariantProps
+}
+
+
+export declare const card: CardRecipe

package/dist/types/styled-system/recipes/carousel.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CarouselVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md"
+}
+
+type CarouselVariantMap = {
+  [key in keyof CarouselVariant]: Array<CarouselVariant[key]>
+}
+
+export type CarouselVariantProps = {
+  [key in keyof CarouselVariant]?: ConditionalValue<CarouselVariant[key]> | undefined
+}
+
+export interface CarouselRecipe {
+  __type: CarouselVariantProps
+  (props?: CarouselVariantProps): Pretty<Record<"root" | "viewport" | "itemGroup" | "item" | "nextTrigger" | "prevTrigger" | "indicatorGroup" | "indicator" | "control", string>>
+  raw: (props?: CarouselVariantProps) => CarouselVariantProps
+  variantMap: CarouselVariantMap
+  variantKeys: Array<keyof CarouselVariant>
+  splitVariantProps<Props extends CarouselVariantProps>(props: Props): [CarouselVariantProps, Pretty<DistributiveOmit<Props, keyof CarouselVariantProps>>]
+  getVariantProps: (props?: CarouselVariantProps) => CarouselVariantProps
+}
+
+
+export declare const carousel: CarouselRecipe