@toriistudio/v0-playground/dist/index.d.ts

V0 Playground

import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React from 'react';
import React__default, { ReactNode } from 'react';
import * as class_variance_authority_types from 'class-variance-authority/types';
import { VariantProps } from 'class-variance-authority';

declare function Playground({ children }: {
    children: ReactNode;
}): react_jsx_runtime.JSX.Element | null;

declare const buttonVariants: (props?: ({
    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
}
declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;

type PaletteChannelKey = "r" | "g" | "b";
type AdvancedPaletteSection = {
    key: string;
    label: string;
    helper?: string;
};
type AdvancedPaletteValue = Record<PaletteChannelKey, number>;
type AdvancedPalette = Record<string, AdvancedPaletteValue>;
type AdvancedPaletteValueSource = AdvancedPaletteValue | Partial<Record<PaletteChannelKey, number>> | string;
type AdvancedPaletteRecordSource = Record<string, AdvancedPaletteValueSource>;
type AdvancedPaletteSource = AdvancedPalette | string[] | AdvancedPaletteRecordSource | undefined;
type AdvancedPaletteRange = {
    min: number;
    max: number;
    step: number;
};
type AdvancedPaletteRanges = Record<string, AdvancedPaletteRange>;
declare const DEFAULT_HEX_PALETTE: AdvancedPaletteRecordSource;
declare const computePaletteGradient: (palette: AdvancedPalette, steps?: number) => string;
declare const createPaletteSignature: (palette: AdvancedPalette) => string;
declare const clonePalette: (palette: AdvancedPalette) => AdvancedPalette;
declare const hexToPaletteValue: (hex: string) => AdvancedPaletteValue;
declare const paletteValueToHex: (value: AdvancedPaletteValue) => string;
declare const createAdvancedPalette: (source?: AdvancedPaletteSource, options?: {
    sectionOrder?: string[];
}) => AdvancedPalette;
declare const DEFAULT_ADVANCED_PALETTE: AdvancedPalette;
declare const advancedPaletteToHexColors: (palette: AdvancedPalette, options?: {
    sectionOrder?: string[];
    fallbackPalette?: AdvancedPalette;
    defaultColor?: string;
}) => string[];
type AdvancedPaletteControlConfig = {
    defaultPalette?: AdvancedPaletteSource;
    sections?: AdvancedPaletteSection[];
    ranges?: AdvancedPaletteRanges;
    channelLabels?: Partial<Record<PaletteChannelKey, string>>;
    hiddenKeyPrefix?: string;
    controlKey?: string;
    gradientSteps?: number;
    onPaletteChange?: (palette: AdvancedPalette) => void;
    onInteraction?: () => void;
    folder?: string;
    folderPlacement?: "top" | "bottom";
};
type ResolvedAdvancedPaletteConfig = AdvancedPaletteControlConfig & {
    defaultPalette: AdvancedPalette;
    sections: AdvancedPaletteSection[];
    ranges: AdvancedPaletteRanges;
    channelLabels: Record<PaletteChannelKey, string>;
    hiddenKeyPrefix: string;
    controlKey: string;
    gradientSteps: number;
};

type MediaType = "image" | "video";
type UploadedMedia = {
    src: string;
    type: MediaType;
};
type PresetMediaEntry = {
    src: string;
    label: string;
    type: MediaType;
};

type BaseControl = {
    hidden?: boolean;
    folder?: string;
    folderPlacement?: "top" | "bottom";
};
type ControlType = ({
    type: "boolean";
    value: boolean;
} & BaseControl) | ({
    type: "number";
    value: number;
    min?: number;
    max?: number;
    step?: number;
} & BaseControl) | ({
    type: "string";
    value: string;
} & BaseControl) | ({
    type: "color";
    value: string;
} & BaseControl) | ({
    type: "select";
    value: string;
    options: Record<string, any>;
} & BaseControl) | ({
    type: "button";
    onClick?: () => void;
    label?: string;
    render?: () => React__default.ReactNode;
} & BaseControl);
type ControlsSchema = Record<string, ControlType>;
type CopyButtonFnArgs = {
    componentName?: string;
    values: Record<string, any>;
    schema: ControlsSchema;
    jsx: string;
    jsonToComponentString: (options: {
        componentName?: string;
        props: Record<string, unknown>;
    }) => string;
};
type MediaUploadControlConfig = {
    folder?: string;
    folderPlacement?: "top" | "bottom";
    presetMedia?: PresetMediaEntry[];
    maxPresetCount?: number;
    onSelectMedia?: (media: UploadedMedia) => void;
    onClear?: () => void;
};
type ControlsConfig = {
    showCopyButton?: boolean;
    showCopyButtonFn?: (args: CopyButtonFnArgs) => string | null | undefined;
    mainLabel?: string;
    showGrid?: boolean;
    showPresentationButton?: boolean;
    showCodeSnippet?: boolean;
    addAdvancedPaletteControl?: ResolvedAdvancedPaletteConfig;
    addMediaUploadControl?: MediaUploadControlConfig;
};
type UseControlsConfig = Omit<ControlsConfig, "addAdvancedPaletteControl"> & {
    addAdvancedPaletteControl?: AdvancedPaletteControlConfig;
};
type UseControlsOptions = {
    componentName?: string;
    config?: UseControlsConfig;
};
declare const ControlsProvider: ({ children }: {
    children: ReactNode;
}) => react_jsx_runtime.JSX.Element;
declare const useControls: <T extends ControlsSchema>(schema: T, options?: UseControlsOptions) => { [K in keyof T]: T[K] extends {
    value: infer V;
} ? V : never; } & {
    controls: Record<string, any>;
    schema: ControlsSchema;
    setValue: (key: string, value: any) => void;
    jsx: () => string;
};
declare const useUrlSyncedControls: <T extends ControlsSchema>(schema: T, options?: UseControlsOptions) => { [K in keyof T]: T[K] extends {
    value: infer V;
} ? V : never; } & {
    controls: Record<string, any>;
    schema: ControlsSchema;
    setValue: (key: string, value: any) => void;
    jsx: () => string;
};

type ControlOverrides = Omit<AdvancedPaletteControlConfig, "defaultPalette" | "onPaletteChange">;
type UseAdvancedPaletteControlsOptions = {
    defaultPalette?: AdvancedPaletteSource;
    fallbackPalette?: AdvancedPaletteSource;
    sectionOrder?: string[];
    defaultColor?: string;
    gradientSteps?: number;
    control?: ControlOverrides;
    onChange?: (palette: AdvancedPalette) => void;
};
type UseAdvancedPaletteControlsResult = {
    palette: Readonly<AdvancedPalette>;
    hexColors: string[];
    controlConfig: AdvancedPaletteControlConfig;
    paletteGradient: string;
    setPalette: (source: AdvancedPaletteSource) => void;
    updatePalette: (updater: (current: AdvancedPalette) => AdvancedPaletteSource) => void;
    resetPalette: () => void;
    paletteSignature: string;
};
declare const useAdvancedPaletteControls: (options?: UseAdvancedPaletteControlsOptions) => UseAdvancedPaletteControlsResult;
declare const useDefaultAdvancedPaletteControls: () => UseAdvancedPaletteControlsResult;

export { type AdvancedPalette, type AdvancedPaletteControlConfig, type AdvancedPaletteRecordSource, type AdvancedPaletteSource, type AdvancedPaletteValueSource, Button, type ControlType, ControlsProvider, type ControlsSchema, type CopyButtonFnArgs, DEFAULT_ADVANCED_PALETTE, DEFAULT_HEX_PALETTE, type MediaUploadControlConfig, type PaletteChannelKey, Playground, type PresetMediaEntry, type UploadedMedia, type UseAdvancedPaletteControlsOptions, type UseAdvancedPaletteControlsResult, advancedPaletteToHexColors, clonePalette, computePaletteGradient, createAdvancedPalette, createPaletteSignature, hexToPaletteValue, paletteValueToHex, useAdvancedPaletteControls, useControls, useDefaultAdvancedPaletteControls, useUrlSyncedControls };