cabloy 5.1.172 → 5.1.173

package/zova/src/suite/a-demo/modules/demo-basic/src/.metadata/index.ts

@@ -37,9 +37,13 @@ declare module 'zova' {
 /** controller: begin */
 export * from '../component/actionView/controller.jsx';
 export * from '../component/card/controller.jsx';
+export * from '../component/controllerBoundaryProbe/controller.jsx';
+export * from '../component/controllerBoundaryProbeInline/controller.jsx';
+export * from '../component/controllerBoundaryProbeOverride/controller.jsx';
 export * from '../component/formFieldTest/controller.jsx';
 export * from '../component/tableCellTest/controller.jsx';
 export * from '../page/component/controller.jsx';
+export * from '../page/controllerBoundary/controller.jsx';
 export * from '../page/locale/controller.jsx';
 export * from '../page/routeParams/controller.jsx';
 export * from '../page/routeQuery/controller.jsx';
@@ -70,6 +74,21 @@ declare module 'zova-module-demo-basic' {
           get scope(): ScopeModuleDemoBasic;
         }
 
+        export interface ControllerControllerBoundaryProbe {
+          /** @internal */
+          get scope(): ScopeModuleDemoBasic;
+        }
+
+        export interface ControllerControllerBoundaryProbeInline {
+          /** @internal */
+          get scope(): ScopeModuleDemoBasic;
+        }
+
+        export interface ControllerControllerBoundaryProbeOverride {
+          /** @internal */
+          get scope(): ScopeModuleDemoBasic;
+        }
+
         export interface ControllerFormFieldTest {
           /** @internal */
           get scope(): ScopeModuleDemoBasic;
@@ -85,6 +104,11 @@ declare module 'zova-module-demo-basic' {
           get scope(): ScopeModuleDemoBasic;
         }
 
+        export interface ControllerPageControllerBoundary {
+          /** @internal */
+          get scope(): ScopeModuleDemoBasic;
+        }
+
         export interface ControllerPageLocale {
           /** @internal */
           get scope(): ScopeModuleDemoBasic;
@@ -149,9 +173,13 @@ declare module 'zova-module-demo-basic' {
 /** controller: begin */
 import type { ControllerActionView } from '../component/actionView/controller.jsx';
 import type { ControllerCard } from '../component/card/controller.jsx';
+import type { ControllerControllerBoundaryProbe } from '../component/controllerBoundaryProbe/controller.jsx';
+import type { ControllerControllerBoundaryProbeInline } from '../component/controllerBoundaryProbeInline/controller.jsx';
+import type { ControllerControllerBoundaryProbeOverride } from '../component/controllerBoundaryProbeOverride/controller.jsx';
 import type { ControllerFormFieldTest } from '../component/formFieldTest/controller.jsx';
 import type { ControllerTableCellTest } from '../component/tableCellTest/controller.jsx';
 import type { ControllerPageComponent } from '../page/component/controller.jsx';
+import type { ControllerPageControllerBoundary } from '../page/controllerBoundary/controller.jsx';
 import type { ControllerPageLocale } from '../page/locale/controller.jsx';
 import type { ControllerPageRouteParams } from '../page/routeParams/controller.jsx';
 import type { ControllerPageRouteQuery } from '../page/routeQuery/controller.jsx';
@@ -169,9 +197,13 @@ declare module 'zova' {
   export interface IBeanRecordLocal {
     'demo-basic.controller.actionView': ControllerActionView;
 'demo-basic.controller.card': ControllerCard;
+'demo-basic.controller.controllerBoundaryProbe': ControllerControllerBoundaryProbe;
+'demo-basic.controller.controllerBoundaryProbeInline': ControllerControllerBoundaryProbeInline;
+'demo-basic.controller.controllerBoundaryProbeOverride': ControllerControllerBoundaryProbeOverride;
 'demo-basic.controller.formFieldTest': ControllerFormFieldTest;
 'demo-basic.controller.tableCellTest': ControllerTableCellTest;
 'demo-basic.controller.pageComponent': ControllerPageComponent;
+'demo-basic.controller.pageControllerBoundary': ControllerPageControllerBoundary;
 'demo-basic.controller.pageLocale': ControllerPageLocale;
 'demo-basic.controller.pageRouteParams': ControllerPageRouteParams;
 'demo-basic.controller.pageRouteQuery': ControllerPageRouteQuery;
@@ -189,6 +221,8 @@ declare module 'zova' {
 /** controller: end */
 /** pages: begin */
 export * from './page/component.js';
+export * from './page/controllerBoundary.js';
+import { NSControllerPageControllerBoundary } from './page/controllerBoundary.js';
 export * from './page/locale.js';
 export * from './page/routeParams.js';
 import { NSControllerPageRouteParams } from './page/routeParams.js';
@@ -214,6 +248,7 @@ import 'zova';
 declare module 'zova-module-a-router' {
 export interface IPagePathRecord {
   '/demo/basic/component': TypePagePathSchema<undefined,undefined>;
+'/demo/basic/controllerBoundary': TypePagePathSchema<NSControllerPageControllerBoundary.ParamsInput,NSControllerPageControllerBoundary.QueryInput>;
 '/demo/basic/locale': TypePagePathSchema<undefined,undefined>;
 '/demo/basic/routeParams/:id?': TypePagePathSchema<NSControllerPageRouteParams.ParamsInput,NSControllerPageRouteParams.QueryInput>;
 '/demo/basic/routeQuery': TypePagePathSchema<NSControllerPageRouteQuery.ParamsInput,NSControllerPageRouteQuery.QueryInput>;
@@ -236,6 +271,9 @@ export interface IPageNameRecord {
 }
 }
 export const pagePathSchemas = {
+'/demo/basic/controllerBoundary': {
+          query: NSControllerPageControllerBoundary.querySchema,
+        },
 '/demo/basic/routeQuery': {
           query: NSControllerPageRouteQuery.querySchema,
         },
@@ -265,7 +303,11 @@ export const pageNameSchemas = {
         },
 };
 declare module 'zova-module-demo-basic' {
-  export interface ControllerPageRouteParams {
+  export interface ControllerPageControllerBoundary {
+        $params: NSControllerPageControllerBoundary.ParamsOutput;
+$query: NSControllerPageControllerBoundary.QueryOutput;
+      }
+export interface ControllerPageRouteParams {
         $params: NSControllerPageRouteParams.ParamsOutput;
 $query: NSControllerPageRouteParams.QueryOutput;
       }
@@ -301,6 +343,12 @@ export * from './component/actionView.js';
 import { ZActionView } from './component/actionView.js';
 export * from './component/card.js';
 import { ZCard } from './component/card.js';
+export * from './component/controllerBoundaryProbe.js';
+import { ZControllerBoundaryProbe } from './component/controllerBoundaryProbe.js';
+export * from './component/controllerBoundaryProbeInline.js';
+import { ZControllerBoundaryProbeInline } from './component/controllerBoundaryProbeInline.js';
+export * from './component/controllerBoundaryProbeOverride.js';
+import { ZControllerBoundaryProbeOverride } from './component/controllerBoundaryProbeOverride.js';
 export * from './component/formFieldTest.js';
 import { ZFormFieldTest } from './component/formFieldTest.js';
 export * from './component/tableCellTest.js';
@@ -308,6 +356,9 @@ import { ZTableCellTest } from './component/tableCellTest.js';
 export const components = {
   'actionView': ZActionView,
 'card': ZCard,
+'controllerBoundaryProbe': ZControllerBoundaryProbe,
+'controllerBoundaryProbeInline': ZControllerBoundaryProbeInline,
+'controllerBoundaryProbeOverride': ZControllerBoundaryProbeOverride,
 'formFieldTest': ZFormFieldTest,
 'tableCellTest': ZTableCellTest,
 };
@@ -316,12 +367,18 @@ declare module 'zova' {
 export interface IComponentRecord {
   'demo-basic:actionView': ControllerActionView;
 'demo-basic:card': ControllerCard;
+'demo-basic:controllerBoundaryProbe': ControllerControllerBoundaryProbe;
+'demo-basic:controllerBoundaryProbeInline': ControllerControllerBoundaryProbeInline;
+'demo-basic:controllerBoundaryProbeOverride': ControllerControllerBoundaryProbeOverride;
 'demo-basic:formFieldTest': ControllerFormFieldTest;
 'demo-basic:tableCellTest': ControllerTableCellTest;
 }
 export interface IZovaComponentRecord {
   'demo-basic:actionView': typeof ZActionView;
 'demo-basic:card': typeof ZCard;
+'demo-basic:controllerBoundaryProbe': typeof ZControllerBoundaryProbe;
+'demo-basic:controllerBoundaryProbeInline': typeof ZControllerBoundaryProbeInline;
+'demo-basic:controllerBoundaryProbeOverride': typeof ZControllerBoundaryProbeOverride;
 'demo-basic:formFieldTest': typeof ZFormFieldTest;
 'demo-basic:tableCellTest': typeof ZTableCellTest;
 }

package/zova/src/suite/a-demo/modules/demo-basic/src/.metadata/page/controllerBoundary.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { createZovaComponentPage } from 'zova';
+
+import { ControllerPageControllerBoundary } from '../../page/controllerBoundary/controller.jsx';
+import {
+  ControllerPageControllerBoundarySchemaParams,
+  ControllerPageControllerBoundarySchemaQuery,
+} from '../../page/controllerBoundary/controller.jsx';
+export namespace NSControllerPageControllerBoundary {
+  export const paramsSchema = ControllerPageControllerBoundarySchemaParams;
+  export type ParamsInput = z.input<typeof ControllerPageControllerBoundarySchemaParams>;
+  export type ParamsOutput = z.output<typeof ControllerPageControllerBoundarySchemaParams>;
+
+  export const querySchema = ControllerPageControllerBoundarySchemaQuery;
+  export type QueryInput = z.input<typeof ControllerPageControllerBoundarySchemaQuery>;
+  export type QueryOutput = z.output<typeof ControllerPageControllerBoundarySchemaQuery>;
+}
+
+export const ZPageControllerBoundary = createZovaComponentPage(
+  ControllerPageControllerBoundary,
+  undefined,
+  undefined,
+);

package/zova/src/suite/a-demo/modules/demo-basic/src/component/controllerBoundaryProbe/controller.tsx

@@ -0,0 +1,36 @@
+import { BeanControllerBase, IComponentOptions } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+export interface ControllerControllerBoundaryProbeProps {
+  mode: 'success' | 'failure' | 'serverFailure';
+  delayMs?: number;
+}
+
+@Controller()
+export class ControllerControllerBoundaryProbe extends BeanControllerBase {
+  static $propsDefault = {
+    delayMs: 800,
+  };
+
+  static $componentOptions: IComponentOptions = {
+    boundary: { loading: { delay: 500 }, retry: true },
+  };
+
+  ready = false;
+
+  protected async __init__() {
+    await new Promise(resolve => setTimeout(resolve, this.$props.delayMs));
+    if (
+      this.$props.mode === 'failure' ||
+      (this.$props.mode === 'serverFailure' && process.env.SERVER)
+    ) {
+      throw new Error('Controller boundary probe initialization failed');
+    }
+    this.ready = true;
+  }
+
+  protected render() {
+    if (!this.ready) return null;
+    return <div>Controller boundary probe ready</div>;
+  }
+}

package/zova/src/suite/a-demo/modules/demo-basic/src/component/controllerBoundaryProbeInline/controller.tsx

@@ -0,0 +1,34 @@
+import { BeanControllerBase, IComponentOptions } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+export interface ControllerControllerBoundaryProbeInlineProps {
+  mode: 'success' | 'failure' | 'serverFailure';
+  delayMs?: number;
+}
+
+@Controller()
+export class ControllerControllerBoundaryProbeInline extends BeanControllerBase {
+  static $propsDefault = {
+    delayMs: 800,
+  };
+
+  static $componentOptions: IComponentOptions = {
+    boundary: { loading: { delay: 500 }, renderMode: 'inline', retry: true },
+  };
+
+  ready = false;
+
+  protected async __init__() {
+    const props = this.$props as ControllerControllerBoundaryProbeInlineProps;
+    await new Promise(resolve => setTimeout(resolve, props.delayMs));
+    if (props.mode === 'failure' || (props.mode === 'serverFailure' && process.env.SERVER)) {
+      throw new Error('Inline Controller boundary probe initialization failed');
+    }
+    this.ready = true;
+  }
+
+  protected render() {
+    if (!this.ready) return null;
+    return <span>Inline Controller boundary probe ready</span>;
+  }
+}

package/zova/src/suite/a-demo/modules/demo-basic/src/component/controllerBoundaryProbeOverride/controller.tsx

@@ -0,0 +1,46 @@
+import type { VNodeChild } from 'vue';
+import type { TypeComponentBoundaryRenderMode } from 'zova';
+
+import { BeanControllerBase, IComponentOptions } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+export interface ControllerControllerBoundaryProbeOverrideProps {
+  mode: 'success' | 'failure';
+  delayMs?: number;
+}
+
+@Controller()
+export class ControllerControllerBoundaryProbeOverride extends BeanControllerBase {
+  static $propsDefault = {
+    delayMs: 800,
+  };
+
+  static $componentOptions: IComponentOptions = {
+    boundary: { loading: { delay: 500 }, renderMode: 'inline' },
+  };
+
+  ready = false;
+
+  protected async __init__() {
+    const props = this.$props as ControllerControllerBoundaryProbeOverrideProps;
+    await new Promise(resolve => setTimeout(resolve, props.delayMs));
+    if (props.mode === 'failure') {
+      throw new Error('Override Controller boundary probe initialization failed');
+    }
+    this.ready = true;
+  }
+
+  protected renderLoading(renderMode: TypeComponentBoundaryRenderMode): VNodeChild {
+    return <span role="status">Override loading mode: {renderMode}</span>;
+  }
+
+  protected renderError(error: unknown): VNodeChild {
+    const message = error instanceof Error ? error.message : String(error);
+    return <span role="alert">Override legacy error: {message}</span>;
+  }
+
+  protected render() {
+    if (!this.ready) return null;
+    return <span>Override Controller boundary probe ready</span>;
+  }
+}

package/zova/src/suite/a-demo/modules/demo-basic/src/page/controllerBoundary/controller.tsx

@@ -0,0 +1,185 @@
+import { z } from 'zod';
+import { BeanControllerPageBase } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+import { ZPage } from 'zova-module-home-base';
+
+import {
+  ZControllerBoundaryProbe,
+  ZControllerBoundaryProbeInline,
+  ZControllerBoundaryProbeOverride,
+} from '../../.metadata/index.jsx';
+
+export const ControllerPageControllerBoundarySchemaParams = z.object({});
+
+export const ControllerPageControllerBoundarySchemaQuery = z.object({
+  mode: z.enum(['serverFailure', 'inlineServerFailure']).optional(),
+});
+
+type ProbeMode = 'success' | 'failure' | 'serverFailure';
+type InlineProbeMode = 'success' | 'failure' | 'serverFailure';
+
+@Controller()
+export class ControllerPageControllerBoundary extends BeanControllerPageBase {
+  probe?: { mode: ProbeMode; delayMs: number };
+  inlineProbe?: { mode: InlineProbeMode; delayMs: number };
+  overrideProbe?: { mode: 'success' | 'failure'; delayMs: number };
+  probeKey = 0;
+  inlineProbeKey = 0;
+  overrideProbeKey = 0;
+
+  protected async __init__() {
+    if (this.$query.mode === 'serverFailure') {
+      this.probe = { mode: 'serverFailure', delayMs: 0 };
+    } else if (this.$query.mode === 'inlineServerFailure') {
+      this.inlineProbe = { mode: 'serverFailure', delayMs: 0 };
+    }
+  }
+
+  mountFastSuccess() {
+    this._mountProbe('success', 300);
+  }
+
+  mountFastFailure() {
+    this._mountProbe('failure', 300);
+  }
+
+  mountDelayedSuccess() {
+    this._mountProbe('success', 800);
+  }
+
+  mountFailingProbe() {
+    this._mountProbe('failure', 800);
+  }
+
+  prepareProbeRetrySuccess() {
+    if (!this.probe) return;
+    this.probe = { mode: 'success', delayMs: 800 };
+  }
+
+  clearProbe() {
+    this.probe = undefined;
+  }
+
+  mountInlineFailingProbe() {
+    this._mountInlineProbe('failure', 800);
+  }
+
+  prepareInlineRetrySuccess() {
+    if (!this.inlineProbe) return;
+    this.inlineProbe = { mode: 'success', delayMs: 800 };
+  }
+
+  clearInlineProbe() {
+    this.inlineProbe = undefined;
+  }
+
+  mountOverrideFailingProbe() {
+    this.overrideProbe = { mode: 'failure', delayMs: 800 };
+    this.overrideProbeKey++;
+  }
+
+  recoverOverrideWithDelayedSuccess() {
+    this.overrideProbe = { mode: 'success', delayMs: 800 };
+    this.overrideProbeKey++;
+  }
+
+  clearOverrideProbe() {
+    this.overrideProbe = undefined;
+  }
+
+  private _mountProbe(mode: ProbeMode, delayMs: number) {
+    this.probe = { mode, delayMs };
+    this.probeKey++;
+  }
+
+  private _mountInlineProbe(mode: InlineProbeMode, delayMs: number) {
+    this.inlineProbe = { mode, delayMs };
+    this.inlineProbeKey++;
+  }
+
+  protected render() {
+    return (
+      <ZPage>
+        <h1>Controller Boundary Manual Validation</h1>
+        <p>
+          Mount a fresh child Controller to exercise the global loading and error boundary
+          renderers.
+        </p>
+        <div class="flex flex-wrap gap-2">
+          <button class="btn btn-primary" onClick={() => this.mountFastSuccess()}>
+            Mount fast success probe
+          </button>
+          <button class="btn btn-error" onClick={() => this.mountFastFailure()}>
+            Mount fast failing probe
+          </button>
+          <button class="btn btn-primary" onClick={() => this.mountDelayedSuccess()}>
+            Mount delayed success probe
+          </button>
+          <button class="btn btn-error" onClick={() => this.mountFailingProbe()}>
+            Mount failing probe
+          </button>
+          <button class="btn btn-secondary" onClick={() => this.prepareProbeRetrySuccess()}>
+            Prepare probe retry success
+          </button>
+          <button class="btn" onClick={() => this.clearProbe()}>
+            Clear probe
+          </button>
+        </div>
+        <div class="mt-4">
+          {this.probe && (
+            <ZControllerBoundaryProbe
+              key={this.probeKey}
+              mode={this.probe.mode}
+              delayMs={this.probe.delayMs}
+            />
+          )}
+        </div>
+        <div class="mt-4">
+          <button class="btn btn-error" onClick={() => this.mountInlineFailingProbe()}>
+            Mount inline failing probe
+          </button>
+          <button class="btn btn-secondary ml-2" onClick={() => this.prepareInlineRetrySuccess()}>
+            Prepare inline retry success
+          </button>
+          <button class="btn ml-2" onClick={() => this.clearInlineProbe()}>
+            Clear inline probe
+          </button>
+          <p class="mt-2">
+            Inline boundary:{' '}
+            {this.inlineProbe && (
+              <ZControllerBoundaryProbeInline
+                key={this.inlineProbeKey}
+                mode={this.inlineProbe.mode}
+                delayMs={this.inlineProbe.delayMs}
+              />
+            )}
+          </p>
+        </div>
+        <div class="mt-4">
+          <button class="btn btn-error" onClick={() => this.mountOverrideFailingProbe()}>
+            Mount override failing probe
+          </button>
+          <button
+            class="btn btn-secondary ml-2"
+            onClick={() => this.recoverOverrideWithDelayedSuccess()}
+          >
+            Recover override with delayed success
+          </button>
+          <button class="btn ml-2" onClick={() => this.clearOverrideProbe()}>
+            Clear override probe
+          </button>
+          <p class="mt-2">
+            Override boundary:{' '}
+            {this.overrideProbe && (
+              <ZControllerBoundaryProbeOverride
+                key={this.overrideProbeKey}
+                mode={this.overrideProbe.mode}
+                delayMs={this.overrideProbe.delayMs}
+              />
+            )}
+          </p>
+        </div>
+      </ZPage>
+    );
+  }
+}

package/zova/src/suite/a-demo/modules/demo-basic/src/routes.ts

@@ -1,6 +1,7 @@
 import type { IModuleRoute } from 'zova-module-a-router';
 
 import { ZPageComponent } from './.metadata/page/component.js';
+import { ZPageControllerBoundary } from './.metadata/page/controllerBoundary.js';
 import { ZPageLocale } from './.metadata/page/locale.js';
 import { ZPageRoutedDialog } from './.metadata/page/routedDialog.js';
 import { ZPageRoutedDialogDetail } from './.metadata/page/routedDialogDetail.js';
@@ -89,4 +90,9 @@ export const routes: IModuleRoute[] = [
     component: ZPageRoutedDialogDetail,
     meta: { requiresAuth: false },
   },
+  {
+    path: 'controllerBoundary',
+    component: ZPageControllerBoundary,
+    meta: { requiresAuth: false, ssrProfile: 'public' },
+  },
 ];

package/zova/src/suite/a-home/modules/home-base/src/config/locale/en-us.ts

@@ -1,6 +1,7 @@
 export default {
   Home: 'Home',
   GoHome: 'Go Home',
+  Retry: 'Retry',
   LanguageEnglish: 'English',
   LanguageChinese: 'Chinese',
   VonaIntegratedSsr: 'Vona integrated SSR',

package/zova/src/suite/a-home/modules/home-base/src/config/locale/zh-cn.ts

@@ -1,6 +1,7 @@
 export default {
   Home: '主页',
   GoHome: '返回首页',
+  Retry: '重试',
   LanguageEnglish: '英语',
   LanguageChinese: '简体中文',
   VonaIntegratedSsr: 'Vona 集成式 SSR',

package/zova/src/suite/a-training/modules/training-student/src/model/student.ts

@@ -24,9 +24,6 @@ export class ModelStudent extends BeanModelBase {
         const res = await this.scope.api.trainingStudent.summary({ params: { id } });
         return res ?? null;
       },
-      meta: {
-        disableErrorEffect: true,
-      },
     });
   }
 

package/zova/src/suite/cabloy-basic/modules/basic-button/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "zova-module-basic-button",
+  "version": "5.0.0",
+  "description": "",
+  "keywords": [
+    "Zova Module"
+  ],
+  "author": "",
+  "files": [
+    "mock",
+    "dist",
+    "src",
+    "icons",
+    "assets"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/zova.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "replace": {
+      "exports.\\..types": "./dist/index.d.ts"
+    },
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "basic-button",
+  "zovaModule": {
+    "dependencies": {
+      "basic-app": "5.0.0",
+      "basic-commands": "5.0.0"
+    }
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-button/src/.metadata/component/button.ts

@@ -0,0 +1,31 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerButtonProps } from '../../component/button/controller.jsx';
+
+import { ControllerButton } from '../../component/button/controller.jsx';
+export type ZButtonProps = {
+  controllerRef?: (ref: ControllerButton) => void;
+} & ControllerButtonProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerButtonProps,
+  keyof typeof ControllerButton.$propsDefault
+>;
+declare module 'zova-module-basic-button' {
+  export interface ControllerButton {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZButton = defineComponent((_props: ZButtonProps) => {
+  useController(ControllerButton, undefined, undefined);
+  return () => {};
+}, prepareComponentOptions(ControllerButton.$componentOptions));
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'basic-button:button': ControllerButtonProps;
+  }
+}