@crisp-ui-kit/crisp 0.54.1 → 0.54.3

package/dist/types/components/emptystate/emptystate.recipe.d.ts

@@ -3,6 +3,7 @@ declare const config: import("../..").RecipeConfig<{
         default: string;
         illustrated: string;
         page: string;
+        records: string;
     };
 }>;
 export declare const emptystateRecipe: import("../..").RecipeFn<{
@@ -10,6 +11,7 @@ export declare const emptystateRecipe: import("../..").RecipeFn<{
         default: string;
         illustrated: string;
         page: string;
+        records: string;
     };
 }>;
 export default config;

package/dist/types/components/emptystate/index.d.ts

@@ -1,2 +1,2 @@
-export { EmptyState, type EmptyStateProps } from "./emptystate";
+export { EmptyState, type EmptyStateLearnMore, type EmptyStateProps, } from "./emptystate";
 export { emptystateRecipe } from "./emptystate.recipe";

package/dist/types/components/mentionchip/index.d.ts

@@ -0,0 +1,2 @@
+export { MentionChip, type MentionChipProps } from "./mentionchip";
+export { mentionChipRecipe } from "./mentionchip.recipe";

package/dist/types/components/mentionchip/mentionchip.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+export type MentionChipProps = React.ComponentPropsWithoutRef<"span"> & {
+    asChild?: boolean;
+};
+/**
+ * A standalone "@mention" chip — the same look `RichTextEditor` draws
+ * inline while an editor is live (`.crisp-rte-mention`), exported on its
+ * own for a consumer rendering a mention OUTSIDE a mounted editor: a
+ * comment thread, a note's collapsed preview, anywhere a stored
+ * `@[Name](actor:id)`-shaped token needs to read as a person, not literal
+ * markup. Renders whatever `children` is given (the trigger character
+ * included, if the caller wants one, matching how `RichTextEditor`'s own
+ * chip includes it) rather than assuming an `@` prefix itself — plain text,
+ * no built-in click/remove behaviour (none was asked for; add one once a
+ * real interaction is measured, the same reasoning `Chip`'s own doc gives
+ * for not guessing a remove affordance).
+ */
+export declare const MentionChip: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLElement>>;

package/dist/types/components/mentionchip/mentionchip.recipe.d.ts

@@ -0,0 +1,18 @@
+declare const spec: {
+    readonly name: "mention-chip";
+    readonly base: {
+        readonly display: "inline";
+        readonly borderRadius: `var(--${string})`;
+        readonly paddingInline: `var(--${string})`;
+        readonly background: `color-mix(in srgb, var(--${string}) 14%, transparent)`;
+        readonly color: `color-mix(in srgb, var(--${string}) 82%, var(--${string}))`;
+        readonly fontWeight: `var(--${string})`;
+        readonly cursor: "default";
+    };
+};
+declare const config: import("../..").RecipeConfig<Record<string, Record<string, string>>>;
+export declare const mentionChipRecipe: import("../..").RecipeFn<Record<string, Record<string, string>>> & {
+    config: import("../..").RecipeConfig<Record<string, Record<string, string>>>;
+};
+export { spec };
+export default config;

package/dist/types/components/personchip/index.d.ts

@@ -0,0 +1 @@
+export * from "./personchip";

package/dist/types/components/personchip/personchip.d.ts

@@ -0,0 +1,37 @@
+import type * as React from "react";
+export type PersonChipProps = Omit<React.ComponentPropsWithoutRef<"span">, "children"> & {
+    /** The person's display name — also the avatar's initials fallback. */
+    name: string;
+    /** A photo URL. Omitted (no populated photo field was reachable to
+     *  measure this round), the avatar falls back to a per-name hashed-colour
+     *  initials tile. */
+    avatar?: string;
+    /** De-emphasises the name (e.g. a departed person, a system actor) —
+     *  `fgNeutralMuted`, the same token `Text`'s own `tone="muted"` uses.
+     *  Applied to the name only; the avatar keeps its full-strength tone so
+     *  the chip still reads as a distinct person, not a disabled control. */
+    muted?: boolean;
+    className?: string;
+};
+/**
+ * A person, as a chip: a small avatar (a photo, or hashed-colour initials)
+ * plus their name, truncating with an ellipsis when it doesn't fit — Attio's
+ * own actor chip (measured live on `techpartners`, Tasks page, "Assigned to"
+ * column): a 16px circular avatar in a neutral `Chip`, `gap: 3px` between
+ * avatar and name (now `Chip`'s own base — every multi-child `Chip` gets
+ * it). Every other value — the pill's height, padding, radius, ring and text
+ * — is already `Chip`'s, unchanged; `PersonChip` adds no recipe of its own.
+ *
+ * Ellipsis only, no `Tooltip` on hover (#623 — no Attio reference for one;
+ * a truncated cell there is revealed by its own click-to-expand, #579, a
+ * different, DataTable-specific interaction).
+ *
+ * Composes `Chip`'s `truncate` CSS directly rather than its string-only
+ * auto-wrap (children here is an avatar plus a name, not a single string),
+ * so the name gets its own `.crisp-chip-label` span while the avatar stays
+ * fixed-size.
+ */
+export declare function PersonChip({ name, avatar, muted, className, ...props }: PersonChipProps): React.JSX.Element;
+export declare namespace PersonChip {
+    var displayName: string;
+}

package/dist/types/components/table/table.d.ts

@@ -8,6 +8,24 @@ export type TableProps = React.ComponentPropsWithoutRef<"table"> & VariantProps<
     scrollProps?: React.ComponentPropsWithoutRef<"div"> & {
         ref?: React.Ref<HTMLDivElement>;
     };
+    /**
+     * Style applied to the `<table>` element itself, as opposed to `style`
+     * (below), which sizes the OUTER bordered wrapper -- crisp/#581.
+     * `DataTable` uses this for its `min-width: <sum of column widths>`,
+     * which forces `<table>` to its true content width and lets
+     * `.crisp-table-scroll`'s existing `overflow-x: auto` scroll it
+     * internally. Putting that same min-width on the outer wrapper
+     * (`style`) instead, as this component used to require, forces the
+     * WRAPPER itself that wide -- a plain block box's width is normally set
+     * by its own container regardless of a child's min-width, so the only
+     * element that should ever be forced wider than its container is the
+     * scrollable one, never an ancestor of it. Getting this backwards is
+     * exactly what made a `DataTable` widen its own page instead of
+     * scrolling in place (internal/grc#117), forcing GRC to hand-build its
+     * own `overflow: hidden` clipping wrapper around it -- which the
+     * crisp-only rule forbids and which this makes unnecessary.
+     */
+    tableStyle?: React.CSSProperties;
 };
 /**
  * A composable data table. Wraps `<table>` in a horizontally scrollable
@@ -32,6 +50,24 @@ export declare const Table: React.ForwardRefExoticComponent<Omit<React.DetailedH
     scrollProps?: React.ComponentPropsWithoutRef<"div"> & {
         ref?: React.Ref<HTMLDivElement>;
     };
+    /**
+     * Style applied to the `<table>` element itself, as opposed to `style`
+     * (below), which sizes the OUTER bordered wrapper -- crisp/#581.
+     * `DataTable` uses this for its `min-width: <sum of column widths>`,
+     * which forces `<table>` to its true content width and lets
+     * `.crisp-table-scroll`'s existing `overflow-x: auto` scroll it
+     * internally. Putting that same min-width on the outer wrapper
+     * (`style`) instead, as this component used to require, forces the
+     * WRAPPER itself that wide -- a plain block box's width is normally set
+     * by its own container regardless of a child's min-width, so the only
+     * element that should ever be forced wider than its container is the
+     * scrollable one, never an ancestor of it. Getting this backwards is
+     * exactly what made a `DataTable` widen its own page instead of
+     * scrolling in place (internal/grc#117), forcing GRC to hand-build its
+     * own `overflow: hidden` clipping wrapper around it -- which the
+     * crisp-only rule forbids and which this makes unnecessary.
+     */
+    tableStyle?: React.CSSProperties;
 } & React.RefAttributes<HTMLTableElement>>;
 export declare const TableHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
 export declare const TableBody: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;

package/dist/types/components/tabs/tabs.d.ts

@@ -1,4 +1,6 @@
 import * as React from "react";
+import type { VariantProps } from "../../core";
+import { tabsRecipe } from "./tabs.recipe";
 export type TabItem = {
     value: string;
     label: React.ReactNode;
@@ -8,7 +10,7 @@ export type TabItem = {
     badge?: React.ReactNode;
     disabled?: boolean;
 };
-export type TabsProps = Omit<React.ComponentPropsWithoutRef<"div">, "value" | "defaultValue" | "children"> & {
+export type TabsProps = Omit<React.ComponentPropsWithoutRef<"div">, "value" | "defaultValue" | "children"> & VariantProps<typeof tabsRecipe> & {
     tabs: TabItem[];
     /** Controlled active value. Omit to let Tabs manage it (see defaultValue). */
     value?: string;
@@ -27,7 +29,7 @@ export type TabsProps = Omit<React.ComponentPropsWithoutRef<"div">, "value" | "d
  * Home/End jump); activation follows focus. Controlled via
  * `value`/`onValueChange`, or uncontrolled from `defaultValue`.
  */
-export declare function Tabs({ tabs, value, defaultValue, onValueChange, leading, children, className, "aria-label": ariaLabel, ...rest }: TabsProps): React.JSX.Element;
+export declare function Tabs({ tabs, value, defaultValue, onValueChange, leading, children, className, fill, "aria-label": ariaLabel, ...rest }: TabsProps): React.JSX.Element;
 export declare namespace Tabs {
     var displayName: string;
 }

package/dist/types/components/tabs/tabs.recipe.d.ts

@@ -1,5 +1,20 @@
-declare const config: import("../..").RecipeConfig<{}>;
-export declare const tabsRecipe: import("../..").RecipeFn<{}> & {
-    config: import("../..").RecipeConfig<{}>;
+declare const config: import("../..").RecipeConfig<{
+    fill: {
+        true: string;
+        false: string;
+    };
+}>;
+export declare const tabsRecipe: import("../..").RecipeFn<{
+    fill: {
+        true: string;
+        false: string;
+    };
+}> & {
+    config: import("../..").RecipeConfig<{
+        fill: {
+            true: string;
+            false: string;
+        };
+    }>;
 };
 export default config;

package/dist/types/components/text/index.d.ts

@@ -0,0 +1,2 @@
+export { Text, type TextProps } from "./text";
+export { textRecipe } from "./text.recipe";

package/dist/types/components/text/text.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+import type { VariantProps } from "../../core";
+import { textRecipe } from "./text.recipe";
+export type TextProps = React.ComponentPropsWithoutRef<"span"> & VariantProps<typeof textRecipe> & {
+    asChild?: boolean;
+};
+/**
+ * Plain coloured text — `tone="default"` (the app's primary text colour) or
+ * `"muted"` — for the runs of text that aren't a Badge, a Chip, a link, or
+ * any of crisp's other typed things: a cell's own yes/no, an empty-state
+ * caption, a secondary line under a heading. One component so every such
+ * spot reaches for crisp's own tokens instead of each hand-writing its own
+ * colour utility for the same two values.
+ *
+ * Renders a `<span>` (inherits its size/weight/line-height from context —
+ * see `text.recipe.ts`'s doc for why `Text` sets none of those itself).
+ */
+export declare const Text: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & VariantProps<import("../..").RecipeFn<{
+    readonly tone: {
+        readonly default: string;
+        readonly muted: string;
+    };
+}> & {
+    config: import("../..").RecipeConfig<{
+        readonly tone: {
+            readonly default: string;
+            readonly muted: string;
+        };
+    }>;
+}> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLSpanElement>>;

package/dist/types/components/text/text.recipe.d.ts

@@ -0,0 +1,40 @@
+declare const spec: {
+    readonly name: "text";
+    readonly base: {
+        readonly display: "inline";
+    };
+    readonly variants: {
+        tone: {
+            default: {
+                color: `var(--${string})`;
+            };
+            muted: {
+                color: `var(--${string})`;
+            };
+        };
+    };
+    readonly defaultVariants: {
+        readonly tone: "default";
+    };
+};
+declare const config: import("../..").RecipeConfig<{
+    readonly tone: {
+        readonly default: string;
+        readonly muted: string;
+    };
+}>;
+export declare const textRecipe: import("../..").RecipeFn<{
+    readonly tone: {
+        readonly default: string;
+        readonly muted: string;
+    };
+}> & {
+    config: import("../..").RecipeConfig<{
+        readonly tone: {
+            readonly default: string;
+            readonly muted: string;
+        };
+    }>;
+};
+export { spec };
+export default config;

package/dist/types/core/floating-stack.d.ts

@@ -11,6 +11,20 @@ export declare function registerFloatingLayer(el: HTMLElement): () => void;
  * right query for "was this click inside some floating child I opened".
  */
 export declare function isInsideLaterFloatingLayer(target: Node, self: HTMLElement | null): boolean;
+/**
+ * True when a layer is registered strictly after `self` — i.e. `self` has
+ * spawned a still-open nested layer of its own (a row's kebab `Menu` inside
+ * `SavedViews`' own panel, e.g.).
+ *
+ * This is `hasOpenFloatingLayer`'s sibling for a caller that DOES register
+ * itself on this stack: `hasOpenFloatingLayer` reads "is the stack
+ * non-empty", which is always true for such a caller once its own layer is
+ * open — checking that before closing on Escape would defer to itself
+ * forever and Escape would never close it. `self`'s own position on the
+ * stack has to be excluded from the count, which `hasOpenFloatingLayer`
+ * cannot do since it takes no argument.
+ */
+export declare function hasNestedFloatingLayer(self: HTMLElement | null): boolean;
 /**
  * True when at least one `Select`/`MultiSelect`/`Menu`/`Popover`/
  * `ContextMenu` is currently open, anywhere (#361).

package/dist/types/core/index.d.ts

@@ -5,7 +5,7 @@ export { defineRecipe } from "./define";
 export { withDescribedBy } from "./dialog-description";
 export { isRtlElement } from "./direction";
 export { FloatingPortal } from "./floating-portal";
-export { hasOpenFloatingLayer, isInsideLaterFloatingLayer, registerFloatingLayer, } from "./floating-stack";
+export { hasNestedFloatingLayer, hasOpenFloatingLayer, isInsideLaterFloatingLayer, registerFloatingLayer, } from "./floating-stack";
 export { formValueStyle } from "./form-value";
 export { type CrispComponentDefaults, type CrispMessages, CrispMessagesProvider, useCrispComponentDefaults, useCrispMessage, useCrispMessages, } from "./i18n";
 export { type MentionAnchor, type MentionMatch, matchMentionTrigger, } from "./mention";

package/dist/types/index.d.ts

@@ -29,9 +29,11 @@ export * from "./components/heatmapchart";
 export * from "./components/input";
 export * from "./components/kbd";
 export * from "./components/linechart";
+export * from "./components/mentionchip";
 export * from "./components/menu";
 export * from "./components/middletruncate";
 export * from "./components/multiselect";
+export * from "./components/personchip";
 export * from "./components/popover";
 export * from "./components/progress";
 export * from "./components/quantitypicker";
@@ -49,6 +51,7 @@ export * from "./components/switch";
 export * from "./components/table";
 export * from "./components/tabletoolbar";
 export * from "./components/tabs";
+export * from "./components/text";
 export * from "./components/textarea";
 export * from "./components/textlink";
 export * from "./components/timepicker";
@@ -64,7 +67,9 @@ export * from "./product/board";
 export * from "./product/command";
 export * from "./product/entitycard";
 export * from "./product/flowcanvas";
+export * from "./product/formdialog";
 export * from "./product/headerbar";
+export * from "./product/importdialog";
 export * from "./product/inbox";
 export * from "./product/listpage";
 export * from "./product/navitem";
@@ -73,11 +78,14 @@ export * from "./product/recordpage";
 export * from "./product/recordpanel";
 export * from "./product/recordstable";
 export * from "./product/richtext";
+export * from "./product/savedviews";
 export * from "./product/settingssection";
 export * from "./product/settingsshell";
 export * from "./product/sidebar";
 export * from "./product/statlist";
 export * from "./product/tasklist";
+export * from "./product/taskstable";
+export * from "./product/themepicker";
 export * from "./product/trialbanner";
 export * from "./product/viewtoggle";
 export * from "./tokens";

package/dist/types/product/formdialog/formdialog.d.ts

@@ -0,0 +1,57 @@
+import * as React from "react";
+/** See `OptionalLabelsContext`. Call from a field wrapper as
+ *  `optional={useFormDialogOptional(required)}`. */
+export declare function useFormDialogOptional(required: boolean): boolean;
+export type FormDialogProps = Omit<React.ComponentPropsWithoutRef<"div">, "title" | "children" | "onSubmit" | "onClose"> & {
+    title: React.ReactNode;
+    /** The primary button's label on an edit dialog ("Save"). Ignored when
+     *  `createMode` is set — Attio's own button always reads "Create record",
+     *  never the object's name (measured live: "New Company"'s dialog still
+     *  says "Create record", not "Create company"). */
+    submitLabel: React.ReactNode;
+    /** Called on submit — click, Enter in a field, or (in `createMode`)
+     *  Cmd/Ctrl+Enter — with whether the "Create more" switch was on at that
+     *  moment. An edit dialog (no switch, always `false`) can ignore it. */
+    onSubmit: (createMore: boolean) => void;
+    onClose: () => void;
+    busy?: boolean;
+    /** Anything the server rejected that belongs to no one field. */
+    error?: React.ReactNode;
+    children: React.ReactNode;
+    /** Widens the dialog for a form with more columns to hold. */
+    wide?: boolean;
+    /** Dialog content width in px, overrides `wide`. */
+    size?: number;
+    /** Bundles Attio's whole "New Company" create-dialog chrome (crisp#548,
+     *  measured live): "(optional)" on every non-required field (via
+     *  `useFormDialogOptional`); a footer of a "Create more" switch and a
+     *  single "Create record ⌘↵" button with NO Cancel — Attio's dialog
+     *  closes only from the header's ×; and Cmd/Ctrl+Enter submitting from
+     *  anywhere inside the dialog, including a portaled Select/DatePicker
+     *  popover. Only ever set by a create dialog — an edit dialog keeps
+     *  Cancel + `submitLabel`, unmeasured territory the audit never touched. */
+    createMode?: boolean;
+    createMoreLabel?: string;
+    cancelLabel?: string;
+    discardTitle?: string;
+    discardConfirmLabel?: string;
+    discardCancelLabel?: string;
+};
+/**
+ * A modal for a create or edit form — crisp's own `Dialog`/`DialogBody`/
+ * `DialogFooter`, plus everything a record-creating form needs beyond plain
+ * chrome (crisp#548, moved out of internal/grc's own `forms.tsx`, called
+ * from nine places there): dirty tracking with a discard-changes confirm
+ * (any click/change/input inside the form marks it dirty; Escape/backdrop/
+ * header-×/Cancel all route through one `requestClose`, which only asks
+ * when something actually changed — a stacked crisp `Dialog`), a
+ * `beforeunload` guard for a reload or external navigation, and
+ * scroll-to-first-invalid-field once a submit attempt finishes (crisp's own
+ * `FormField` already marks every control `aria-invalid`, so this needs no
+ * per-field wiring). A record needs several fields at once to be valid,
+ * which is why records are not created by inline editing.
+ */
+export declare function FormDialog({ title, submitLabel, onSubmit, onClose, busy, error, children, wide, size, createMode, createMoreLabel: createMoreLabelProp, cancelLabel: cancelLabelProp, discardTitle: discardTitleProp, discardConfirmLabel: discardConfirmLabelProp, discardCancelLabel: discardCancelLabelProp, className, ...rest }: FormDialogProps): React.JSX.Element;
+export declare namespace FormDialog {
+    var displayName: string;
+}

package/dist/types/product/formdialog/formdialog.recipe.d.ts

@@ -0,0 +1,3 @@
+declare const config: import("../..").RecipeConfig<{}>;
+export declare const formdialogRecipe: import("../..").RecipeFn<{}>;
+export default config;

package/dist/types/product/formdialog/index.d.ts

@@ -0,0 +1,2 @@
+export { FormDialog, type FormDialogProps, useFormDialogOptional, } from "./formdialog";
+export { formdialogRecipe } from "./formdialog.recipe";

package/dist/types/product/importdialog/importdialog.d.ts

@@ -0,0 +1,86 @@
+import type { FileRejection, UseFileUploadProps } from "@seed-design/react-file-upload";
+import * as React from "react";
+export type { FileRejection };
+export type ImportDialogStep = {
+    /** Stable id, compared against `activeStep`. */
+    id: string;
+    label: React.ReactNode;
+};
+/**
+ * Root props land on the DIALOG SURFACE — same convention as `Dialog`/
+ * `Drawer` (#223): the element a consumer actually wants to reach (for
+ * `aria-describedby`, a `data-testid`, a `style`) is the panel, not the
+ * portal wrapper.
+ */
+export type ImportDialogProps = Omit<React.ComponentPropsWithoutRef<"div">, "title" | "children"> & {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Header title (default "Import"). */
+    title?: React.ReactNode;
+    /** The fixed step header — id + label pairs, in order. */
+    steps: ImportDialogStep[];
+    /** Which step's id is current — drives both the header pill and, when a
+     * consumer wires `onStepClick`, which row gets `aria-current`. */
+    activeStep: string;
+    /** Fired when an earlier step's pill is clicked. Omit to make the header
+     * display-only (Attio's own back-navigation between steps wasn't part of
+     * this measurement pass). */
+    onStepClick?: (id: string) => void;
+    /** The active step's body. */
+    children?: React.ReactNode;
+    /** Primary action label (e.g. "Next", "Import 40 rows"). Default "Next". */
+    primaryLabel?: React.ReactNode;
+    onPrimary?: () => void;
+    primaryDisabled?: boolean;
+    "aria-label"?: string;
+    /** aria-label on the close button (default "Close"). */
+    closeLabel?: string;
+};
+/**
+ * A full-viewport step wizard — Attio's own CSV import flow (measured live:
+ * `1584x871` filling a ~1600x900 viewport, `border-radius: 0`, no shadow,
+ * opaque white). Composes Zag's dialog machine for focus-trap/scroll-lock/
+ * Escape exactly like `Dialog`/`Drawer`, with its own recipe for the
+ * full-bleed chrome neither of those two share (see importdialog.recipe.ts).
+ *
+ * The step header and footer are generic — the wizard doesn't know about
+ * CSV. Step 1's body is typically `ImportDialogDropzone`; steps 2-4
+ * (map columns / review values / preview import) are consumer-supplied
+ * `children`, since Attio's own column-mapping UI wasn't part of this
+ * measurement pass.
+ */
+export declare function ImportDialog({ open, onOpenChange, title, steps, activeStep, onStepClick, children, primaryLabel, onPrimary, primaryDisabled, "aria-label": ariaLabel, closeLabel: closeLabelProp, className, style, "aria-describedby": describedBy, ...rest }: ImportDialogProps): React.JSX.Element | null;
+export declare namespace ImportDialog {
+    var displayName: string;
+}
+export type ImportDialogDropzoneProps = Omit<React.ComponentPropsWithoutRef<"div">, "children" | "onDrop"> & {
+    /** Accepted file type(s), e.g. ".csv" (the default) or "text/csv". */
+    accept?: UseFileUploadProps["accept"];
+    disabled?: boolean;
+    maxFileSize?: number;
+    /** Fired with the accepted file. One file per drop/pick — a CSV import
+     * has exactly one source file, unlike the generic `FileUpload` list. */
+    onFileAccept?: (file: File) => void;
+    onFileReject?: (rejections: FileRejection[]) => void;
+    dropLabel?: React.ReactNode;
+    orLabel?: React.ReactNode;
+    chooseLabel?: React.ReactNode;
+    learnMoreHref?: string;
+    learnMoreLabel?: React.ReactNode;
+};
+/**
+ * The step-1 drop target — measured chrome (`border: 1px dashed
+ * rgb(230,231,234)`, `border-radius: 20px`, `background: rgb(251,251,251)`)
+ * over the SAME headless drag/drop + file-picker engine `FileUpload` uses
+ * (`@seed-design/react-file-upload`'s `useFileUpload`), rather than a fork
+ * of it. `FileUpload`'s own rendered markup (a single button carrying one
+ * title + one hint) can't host this dropzone's four separate pieces of copy
+ * — a title, an "or" divider, a "Choose a .CSV file" trigger, and a "Learn
+ * more" link that needs its own `<a href>` — so this composes the hook
+ * directly instead of wrapping `<FileUpload>`, and the engine (not this
+ * file) still owns every bit of drag-state/accept/reject behaviour.
+ */
+export declare function ImportDialogDropzone({ accept, disabled, maxFileSize, onFileAccept, onFileReject, dropLabel, orLabel, chooseLabel, learnMoreHref, learnMoreLabel, className, id, ...rest }: ImportDialogDropzoneProps): React.JSX.Element;
+export declare namespace ImportDialogDropzone {
+    var displayName: string;
+}

package/dist/types/product/importdialog/importdialog.recipe.d.ts

@@ -0,0 +1,3 @@
+declare const config: import("../..").RecipeConfig<{}>;
+export declare const importdialogRecipe: import("../..").RecipeFn<{}>;
+export default config;

package/dist/types/product/importdialog/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./importdialog";
+export * from "./importdialog.recipe";

package/dist/types/product/recordstable/recordstable.d.ts

@@ -1,9 +1,14 @@
 import * as React from "react";
+import { type EmptyStateLearnMore } from "../../components/emptystate";
 import type { EditableOption } from "./editable-field";
 type IconType = React.ComponentType<{
     size?: number;
     strokeWidth?: number;
 }>;
+export declare function isLabelTruncated(el: {
+    scrollWidth: number;
+    clientWidth: number;
+}): boolean;
 export type ColumnType = "entity" | "text" | "tags" | "number" | "url" | "date" | "currency" | "status" | "reference";
 export type StatusOption = {
     value: string;
@@ -123,6 +128,20 @@ export type RecordsTableProps = Omit<React.ComponentPropsWithoutRef<"div">, "chi
      * stable colour per name, matching what `DataTable`'s `avatarTone` offers).
      * Entity avatars only — `TAG_TONES`/tag/status tone logic is untouched. */
     avatarTone?: "brand" | "hashed";
+    /**
+     * #603: Attio's zero-*records* state (nothing imported yet, no active
+     * filter) adds an "Import CSV" / "Connect data source" pair and a
+     * "Learn more" card next to the usual "New record" action -- measured
+     * on Users/Workspaces, which show nothing else. Omit any of these and
+     * that piece is left out; omit the whole prop and the empty state is
+     * unchanged (just "New record"), since this hasn't been confirmed for
+     * every object type.
+     */
+    emptyStateExtra?: {
+        onImportCsv?: () => void;
+        onConnectDataSource?: () => void;
+        learnMore?: EmptyStateLearnMore;
+    };
     className?: string;
 };
 export declare function tagTone(t: string): string;
@@ -204,6 +223,9 @@ export type RecordsTableLabels = {
     setRecordPlaceholder: string;
     noRecords: string;
     untitled: string;
+    /** #603: the zero-records state's optional extra CTAs. */
+    importCsv: string;
+    connectDataSource: string;
     /** Aggregation names, keyed by the aggregation. */
     agg: Record<Agg, string>;
     /** Filter operator names, keyed by the operator. */
@@ -229,7 +251,7 @@ export type RecordsTableLabelsInput = Partial<Omit<RecordsTableLabels, "agg" | "
     agg?: Partial<Record<Agg, string>>;
     op?: Partial<Record<FilterOp, string>>;
 };
-type FilterOp = "contains" | "is" | "isnot" | "empty" | "notempty";
+type FilterOp = "contains" | "doesnotcontain" | "startswith" | "endswith" | "is" | "isnot" | "empty" | "notempty";
 /**
  * A date-only cell is a CALENDAR DATE, not an instant. ECMA-262 parses the
  * date-only ISO forms — `1998`, `1998-09`, `1998-09-04` — as UTC midnight, and
@@ -251,6 +273,6 @@ export { formatCellDate, parseCellDate };
  * and a floating bulk-action bar (delete / deselect) when rows are selected.
  * Selection can be controlled via `selectedIds`/`onSelectionChange`.
  */
-export declare function RecordsTable({ labels, columns: columnsProp, rows: rowsProp, selectedIds, onSelectionChange, showNew, allowAddColumn, onOpenRecord, onOpenRecordPage, avatarTone, className, ...rest }: RecordsTableProps): React.JSX.Element;
+export declare function RecordsTable({ labels, columns: columnsProp, rows: rowsProp, selectedIds, onSelectionChange, showNew, allowAddColumn, onOpenRecord, onOpenRecordPage, avatarTone, emptyStateExtra, className, ...rest }: RecordsTableProps): React.JSX.Element;
 export declare const defaultColumns: Column[];
 export declare const defaultRows: Row[];

package/dist/types/product/savedviews/index.d.ts

@@ -0,0 +1,2 @@
+export { type SavedView, SavedViews, type SavedViewsProps, } from "./savedviews";
+export { savedviewsRecipe } from "./savedviews.recipe";