@printstack/print-studio 0.0.0-stage → 0.1.0

package/components/base-dialog/base-dialog.vue.d.ts

@@ -0,0 +1,56 @@
+import { DialogCloseContext } from 'tdesign-vue-next';
+import { BaseDialogProps } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        header?: (props: {}) => any;
+    } & {
+        'header-actions'?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<BaseDialogProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: (context: {
+        e: MouseEvent;
+    }) => any;
+    close: (context: DialogCloseContext) => any;
+    closed: () => any;
+    confirm: (context: {
+        e: KeyboardEvent | MouseEvent;
+    }) => any;
+    opened: () => any;
+    "update:visible": (visible: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<BaseDialogProps> & Readonly<{
+    onCancel?: ((context: {
+        e: MouseEvent;
+    }) => any) | undefined;
+    onClose?: ((context: DialogCloseContext) => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onConfirm?: ((context: {
+        e: KeyboardEvent | MouseEvent;
+    }) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+}>, {
+    width: string | number;
+    footer: boolean;
+    draggable: boolean;
+    destroyOnClose: boolean;
+    bodyPadding: boolean;
+    closable: boolean;
+    closeOnEscKeydown: boolean;
+    closeOnOverlayClick: boolean;
+    confirmLoading: boolean;
+    confirmOnEnter: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/base-dialog/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BaseDialog } from './base-dialog.vue';
+export type { BaseDialogProps } from './types';

package/components/base-dialog/types.d.ts

@@ -0,0 +1,20 @@
+import { DialogCloseContext, DialogProps } from 'tdesign-vue-next';
+export interface BaseDialogProps {
+    beforeClose?: (context: DialogCloseContext) => boolean;
+    bodyPadding?: boolean;
+    cancelBtn?: DialogProps['cancelBtn'];
+    closable?: boolean;
+    closeOnEscKeydown?: boolean;
+    closeOnOverlayClick?: boolean;
+    confirmBtn?: DialogProps['confirmBtn'];
+    confirmLoading?: boolean;
+    confirmOnEnter?: boolean;
+    destroyOnClose?: boolean;
+    draggable?: boolean;
+    footer?: boolean;
+    height?: number | string;
+    title: string;
+    visible: boolean;
+    width?: number | string;
+    zIndex?: number;
+}

package/components/button-group/ButtonGroup.d.ts

@@ -0,0 +1,64 @@
+import { PropType } from 'vue';
+import { ButtonGroupClickContext, ButtonGroupProps } from './types/button-group';
+declare const ButtonGroup: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    actions: {
+        required: true;
+        type: PropType<ButtonGroupProps["actions"]>;
+    };
+    disabled: {
+        default: undefined;
+        type: PropType<ButtonGroupProps["disabled"]>;
+    };
+    gap: {
+        default: number;
+        type: PropType<ButtonGroupProps["gap"]>;
+    };
+    loading: {
+        default: undefined;
+        type: PropType<ButtonGroupProps["loading"]>;
+    };
+    size: {
+        default: undefined;
+        type: PropType<ButtonGroupProps["size"]>;
+    };
+    wrap: {
+        default: boolean;
+        type: PropType<ButtonGroupProps["wrap"]>;
+    };
+}>, () => import('vue/jsx-runtime').JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (_: ButtonGroupClickContext) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    actions: {
+        required: true;
+        type: PropType<ButtonGroupProps["actions"]>;
+    };
+    disabled: {
+        default: undefined;
+        type: PropType<ButtonGroupProps["disabled"]>;
+    };
+    gap: {
+        default: number;
+        type: PropType<ButtonGroupProps["gap"]>;
+    };
+    loading: {
+        default: undefined;
+        type: PropType<ButtonGroupProps["loading"]>;
+    };
+    size: {
+        default: undefined;
+        type: PropType<ButtonGroupProps["size"]>;
+    };
+    wrap: {
+        default: boolean;
+        type: PropType<ButtonGroupProps["wrap"]>;
+    };
+}>> & Readonly<{
+    onClick?: ((_: ButtonGroupClickContext) => any) | undefined;
+}>, {
+    loading: boolean | undefined;
+    gap: number | undefined;
+    size: "small" | "medium" | "large" | undefined;
+    disabled: boolean | undefined;
+    wrap: boolean | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export { ButtonGroup as default };

package/components/button-group/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ButtonGroup } from './ButtonGroup.tsx';
+export type * from './types/button-group';

package/components/error-fallback/ErrorBoundary.d.ts

@@ -0,0 +1,15 @@
+import { PropType } from 'vue';
+import { ErrorRuntime } from './core';
+export declare const ErrorBoundary: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    runtime: {
+        required: true;
+        type: PropType<ErrorRuntime>;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | null | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    runtime: {
+        required: true;
+        type: PropType<ErrorRuntime>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/components/error-fallback/browser.d.ts

@@ -0,0 +1,7 @@
+import { ErrorRuntime } from './core';
+export interface BrowserErrorOptions {
+    captureResources?: boolean;
+    suppressDefault?: boolean;
+    target?: Window;
+}
+export declare function installBrowserErrors(runtime: ErrorRuntime, options?: BrowserErrorOptions): () => void;

package/components/error-fallback/core.d.ts

@@ -0,0 +1,36 @@
+export interface ErrorContext {
+    info?: string;
+    metadata?: Readonly<Record<string, unknown>>;
+    source: string;
+}
+export interface ErrorEvent {
+    context: ErrorContext;
+    error: unknown;
+}
+export interface ErrorDecision {
+    code?: string;
+    data?: unknown;
+    handled: boolean;
+    report?: boolean;
+}
+export interface ErrorResult extends ErrorDecision {
+    duplicate: boolean;
+}
+export interface ErrorRule {
+    handle(event: ErrorEvent): ErrorDecision | Promise<ErrorDecision>;
+    match(event: ErrorEvent): boolean;
+}
+export interface ErrorRuntimeOptions {
+    defaultRules?: boolean;
+    onFailure?(failure: unknown, event: ErrorEvent): Promise<void> | void;
+    report?(event: ErrorEvent, decision: ErrorDecision): Promise<void> | void;
+    rules?: readonly ErrorRule[];
+}
+export interface ErrorRuntime {
+    addRule(rule: ErrorRule, options?: {
+        prepend?: boolean;
+    }): () => void;
+    capture(error: unknown, context?: ErrorContext): Promise<ErrorResult>;
+    subscribe(listener: (event: ErrorEvent) => void): () => void;
+}
+export declare function createErrorRuntime(options?: ErrorRuntimeOptions): ErrorRuntime;

package/components/error-fallback/exceptions/SilentException.d.ts

@@ -0,0 +1,7 @@
+declare const silentExceptionBrand: unique symbol;
+export declare class SilentException extends Error {
+    readonly [silentExceptionBrand] = true;
+    constructor(message?: string, options?: ErrorOptions);
+}
+export declare function isSilentException(error: unknown): error is SilentException;
+export {};

package/components/error-fallback/index.d.ts

@@ -0,0 +1,8 @@
+export { installBrowserErrors } from './browser';
+export type { BrowserErrorOptions } from './browser';
+export { createErrorRuntime } from './core';
+export type { ErrorContext, ErrorDecision, ErrorEvent, ErrorResult, ErrorRule, ErrorRuntime, ErrorRuntimeOptions, } from './core';
+export { ErrorBoundary } from './ErrorBoundary';
+export { isSilentException, SilentException, } from './exceptions/SilentException';
+export { silentExceptionRule } from './rules/silent-exception';
+export { installVueErrors } from './vue';

package/components/error-fallback/rules/silent-exception.d.ts

@@ -0,0 +1,2 @@
+import { ErrorRule } from '../core';
+export declare const silentExceptionRule: ErrorRule;

package/components/error-fallback/vue.d.ts

@@ -0,0 +1,3 @@
+import { App } from 'vue';
+import { ErrorRuntime } from './core';
+export declare function installVueErrors(app: App, runtime: ErrorRuntime): () => void;

package/components/popup-layer/container.d.ts

@@ -0,0 +1,2 @@
+import { InjectionKey } from 'vue';
+export declare const PopupContainerKey: InjectionKey<() => HTMLElement | undefined>;

package/components/popup-layer/use-popup-layer.d.ts

@@ -0,0 +1,6 @@
+import { PopupProps, PopupVisibleChangeContext } from 'tdesign-vue-next';
+import { MaybeRefOrGetter } from 'vue';
+export declare function usePopupLayer(options?: MaybeRefOrGetter<PopupProps>, visibilityEvent?: 'popup' | 'popupProps', controlledVisible?: MaybeRefOrGetter<boolean | undefined>): {
+    onVisibleChange: (value: boolean, context: PopupVisibleChangeContext) => void;
+    popupProps: import('vue').ComputedRef<import('tdesign-vue-next').TdPopupProps>;
+};

package/components/popup-layer/with-popup-layer.d.ts

@@ -0,0 +1,37 @@
+import { PopupProps } from 'tdesign-vue-next';
+import { Component, PropType } from 'vue';
+export declare function withPopupLayer(component: Component, visibilityEvent?: 'popup' | 'popupProps'): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        default: undefined;
+        type: null;
+    };
+    popupProps: {
+        default: undefined;
+        type: PropType<PopupProps>;
+    };
+    popupVisible: {
+        default: undefined;
+        type: BooleanConstructor;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        default: undefined;
+        type: null;
+    };
+    popupProps: {
+        default: undefined;
+        type: PropType<PopupProps>;
+    };
+    popupVisible: {
+        default: undefined;
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: any;
+    popupProps: import('tdesign-vue-next').TdPopupProps;
+    popupVisible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/components/print-s-logo/print-s-logo.vue.d.ts

@@ -0,0 +1,12 @@
+interface Props {
+    holdMs?: number;
+    transitionMs?: number;
+    variant?: 'dark' | 'light';
+}
+declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    variant: "dark" | "light";
+    holdMs: number;
+    transitionMs: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/components/s-form/FieldRenderer.d.ts

@@ -0,0 +1,21 @@
+import { PropType } from 'vue';
+import { SFormSchemaItem } from './types';
+/**
+ * 单个字段的渲染器：t-form-item（label / 状态 / 消息展示）+ 已注册的表单组件。
+ * 值经 SFormContext 读写，插槽经 SForm 透传；
+ * 用户输入路径负责置 touched 并调度校验，失焦路径调度 blur 校验。
+ */
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    item: {
+        required: true;
+        type: PropType<SFormSchemaItem>;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    item: {
+        required: true;
+        type: PropType<SFormSchemaItem>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/s-form/SForm.d.ts

@@ -0,0 +1,77 @@
+import { PropType } from 'vue';
+import { SFormLayoutConfig, SFormLayoutType, SFormSchema, SFormValues } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    disabled: {
+        default: undefined;
+        type: BooleanConstructor;
+    };
+    formProps: {
+        default: () => {};
+        type: PropType<Record<string, unknown>>;
+    };
+    layout: {
+        default: () => SFormLayoutConfig;
+        type: PropType<SFormLayoutConfig | SFormLayoutType>;
+    };
+    modelValue: {
+        default: () => {};
+        type: PropType<SFormValues>;
+    };
+    omitHiddenValues: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    readonly: {
+        default: undefined;
+        type: BooleanConstructor;
+    };
+    schema: {
+        required: true;
+        type: PropType<SFormSchema>;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: (_value: SFormValues) => true;
+    'update:modelValue': (_value: SFormValues) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    disabled: {
+        default: undefined;
+        type: BooleanConstructor;
+    };
+    formProps: {
+        default: () => {};
+        type: PropType<Record<string, unknown>>;
+    };
+    layout: {
+        default: () => SFormLayoutConfig;
+        type: PropType<SFormLayoutConfig | SFormLayoutType>;
+    };
+    modelValue: {
+        default: () => {};
+        type: PropType<SFormValues>;
+    };
+    omitHiddenValues: {
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    readonly: {
+        default: undefined;
+        type: BooleanConstructor;
+    };
+    schema: {
+        required: true;
+        type: PropType<SFormSchema>;
+    };
+}>> & Readonly<{
+    onSubmit?: ((_value: SFormValues) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: SFormValues) => any) | undefined;
+}>, {
+    layout: keyof import('./types').SFormLayoutRegistry | SFormLayoutConfig;
+    disabled: boolean;
+    modelValue: SFormValues;
+    readonly: boolean;
+    formProps: Record<string, unknown>;
+    omitHiddenValues: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/s-form/adapter.d.ts

@@ -0,0 +1,61 @@
+import { Component } from 'vue';
+import { SFormFieldMessages, SFormValidateStatus, SFormValues } from './types';
+/**
+ * 单条规则的校验结果（adapter 中立契约，UI 库差异收敛在 validateField 内）
+ */
+export interface SFormRuleCheckResult {
+    message?: string;
+    result: boolean;
+    /** 失败分级：error 阻塞提交，warning 仅提示（无 warning 标记即按 error 处理） */
+    type?: 'error' | 'warning';
+}
+/**
+ * itemBindings 的解析输入：FieldRenderer 从 schema 一等属性与状态层归集后传入
+ */
+export interface SFormItemBindingInput {
+    field: string;
+    /**
+     * 手动帮助文案（恒展示，对齐 antd help 覆盖语义）
+     */
+    help?: string;
+    label?: string;
+    /**
+     * 状态层派生的校验消息（展示与否由 showMessage 决定）
+     */
+    messages: SFormFieldMessages;
+    /**
+     * 一等必填显示（对齐 antd Form.Item required）
+     */
+    required?: boolean;
+    /**
+     * 表单级 requiredMark 是否已钉死（true / false）；未钉死为 undefined
+     */
+    requiredMarkPinned?: boolean;
+    rules?: unknown[];
+    /**
+     * 是否展示校验消息（回落 formProps.showErrorMessage，默认 true）
+     */
+    showMessage?: boolean;
+    /**
+     * 最终解析后的校验状态（手动覆盖或自动推导，validating 直接透传）
+     */
+    status?: SFormValidateStatus;
+}
+export interface SFormAdapter {
+    clearValidate(instance: unknown, fields?: string[]): void;
+    form: Component;
+    formBindings(values: SFormValues, props: Record<string, unknown>): Record<string, unknown>;
+    formItem: Component;
+    itemBindings(input: SFormItemBindingInput, props: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * 校验单字段：按 UI 库规则语义执行全部规则，返回失败项（已补默认消息）
+     */
+    validateField(value: unknown, rules: unknown[], context: {
+        field: string;
+        label?: string;
+        values: SFormValues;
+    }): Promise<SFormRuleCheckResult[]>;
+}
+export declare const tdesignSFormAdapter: SFormAdapter;
+export declare function setSFormAdapter(adapter: SFormAdapter): void;
+export declare function getSFormAdapter(): SFormAdapter;

package/components/s-form/builtin.d.ts

@@ -0,0 +1 @@
+export {};

package/components/s-form/context.d.ts

@@ -0,0 +1,44 @@
+import { InjectionKey, Slots } from 'vue';
+import { SFormAdapter } from './adapter';
+import { SFormFieldState, SFormValues } from './types';
+/**
+ * SForm 向字段渲染器与自定义控件下发的能力
+ */
+export interface SFormContext {
+    adapter: SFormAdapter;
+    collectFieldRef: (field: string, instance: unknown) => void;
+    /**
+     * 表单级禁用（一等 disabled 与 formProps.disabled 合并后的最终值）
+     */
+    disabled: boolean;
+    /**
+     * 字段 → 响应式校验状态记录（缺省 key 表示该字段尚无状态）；
+     * 随用户输入与校验过程实时更新
+     */
+    fieldStates: Record<string, SFormFieldState>;
+    /**
+     * 控件失焦路径：调度 blur 校验
+     */
+    markFieldBlur: (field: string) => void;
+    /**
+     * 用户输入路径：置 touched + 调度 change 校验（含 dependencies 联动）
+     */
+    markFieldInput: (field: string) => void;
+    /**
+     * 表单级只读（一等 readonly 与 formProps.readonly 合并后的最终值）
+     */
+    readonly: boolean;
+    /**
+     * 表单级 requiredMark 是否钉死（true / false）；未设置时 undefined，
+     * 供 adapter 做必填星号补偿判断
+     */
+    requiredMarkPinned: boolean | undefined;
+    setFieldValue: (field: string, value: unknown) => void;
+    /**
+     * 校验消息是否展示（回落 formProps.showErrorMessage，默认 true）
+     */
+    showMessage: boolean;
+    slots: Slots;
+    values: SFormValues;
+}
+export declare const SFormContextKey: InjectionKey<SFormContext>;

package/components/s-form/diagnostics.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 诊断通道（模块级单例）：s-form 全部告警 / 错误的统一出口。
+ *
+ * - reportError：数据正确性问题（重复 field、未注册组件 / 布局、非法调用时序等），
+ *   生产环境同样输出——这类问题静默远比白屏难排查
+ * - reportWarning：开发期提示（重复注册覆盖、契约缺失等），仅开发环境输出
+ *
+ * 通道本身可整体替换（默认 console），业务侧可通过 setSFormDiagnostics
+ * 接入统一日志采集 / 监控上报，实现与输出媒介解耦。
+ */
+export interface SFormDiagnostics {
+    error(message: string): void;
+    warn(message: string): void;
+}
+export declare function setSFormDiagnostics(diagnostics: SFormDiagnostics): void;
+/**
+ * 恢复默认 console 通道（测试 / 运行时回退用）
+ */
+export declare function resetSFormDiagnostics(): void;
+export declare function getSFormDiagnostics(): SFormDiagnostics;
+/**
+ * 开发期提示：仅开发环境输出
+ */
+export declare function reportWarning(message: string): void;
+/**
+ * 数据正确性错误：全环境输出，经可替换通道转发
+ */
+export declare function reportError(message: string): void;

package/components/s-form/field-status.d.ts

@@ -0,0 +1,18 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { SFormValidateStatus } from './types';
+/**
+ * antd Form.Item.useStatus() 的对等物：
+ * 自定义控件注入所在字段包装层的实时校验状态
+ */
+export interface SFormFieldStatus {
+    errors: ComputedRef<string[]>;
+    status: ComputedRef<SFormValidateStatus | undefined>;
+    touched: ComputedRef<boolean>;
+    warnings: ComputedRef<string[]>;
+}
+export declare const SFormFieldContextKey: InjectionKey<SFormFieldStatus>;
+/**
+ * 在已注册的表单控件内部调用，读取包装它的字段的实时校验状态
+ * （对齐 antd Form.Item.useStatus：脱离字段包装层时 status 为 undefined）
+ */
+export declare function useSFormFieldStatus(): SFormFieldStatus;

package/components/s-form/index.d.ts

@@ -0,0 +1,15 @@
+export { getSFormAdapter, setSFormAdapter, tdesignSFormAdapter, } from './adapter';
+export type { SFormAdapter, SFormItemBindingInput, SFormRuleCheckResult, } from './adapter';
+export { SFormContextKey } from './context';
+export type { SFormContext } from './context';
+export { getSFormDiagnostics, reportError, reportWarning, resetSFormDiagnostics, setSFormDiagnostics, } from './diagnostics';
+export type { SFormDiagnostics } from './diagnostics';
+export { SFormFieldContextKey, useSFormFieldStatus } from './field-status';
+export type { SFormFieldStatus } from './field-status';
+export { BUILTIN_LAYOUT_TYPES, getSFormComponent, getSFormLayout, isBuiltinSFormLayoutType, registerSFormComponent, registerSFormComponents, registerSFormLayout, registerSFormLayouts, unregisterSFormComponent, unregisterSFormLayout, } from './registry';
+export type { RegisterSFormOptions, SFormBuiltinLayoutType } from './registry';
+export { default as SForm } from './SForm';
+export { createSFormStateStore, resolveFieldStatus } from './states';
+export type { SFormStateStore, SFormStateStoreConfig, SFormValidateTrigger, } from './states';
+export * from './types';
+export { buildAncestorGroups, cloneValue, cloneValues, collectFieldPaths, collectHiddenFieldPaths, executeRevealChain, omitPaths, } from './utils';

package/components/s-form/layouts/CollapseToggle.d.ts

@@ -0,0 +1,28 @@
+import { PropType } from 'vue';
+/**
+ * 内置布局共用的「展开/收起」切换按钮
+ */
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    collapsed: {
+        required: true;
+        type: BooleanConstructor;
+    };
+    text: {
+        default: undefined;
+        type: PropType<[string, string] | undefined>;
+    };
+}>, () => import('vue/jsx-runtime').JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "toggle"[], "toggle", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    collapsed: {
+        required: true;
+        type: BooleanConstructor;
+    };
+    text: {
+        default: undefined;
+        type: PropType<[string, string] | undefined>;
+    };
+}>> & Readonly<{
+    onToggle?: ((...args: any[]) => any) | undefined;
+}>, {
+    text: [string, string] | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;