@qlover/create-app 0.7.14 → 0.8.0

package/dist/templates/next-app/src/app/[locale]/admin/users/page.tsx

@@ -1,68 +1,66 @@
 'use client';
 
-import { Table } from 'antd';
-import { useEffect, useRef } from 'react';
-import { AdminUserService } from '@/base/services/AdminUserService';
+import { ResourceTable } from '@brain-toolkit/antd-blocks/resourceTable/ResourceTable';
+import { ResourceTableHeader } from '@brain-toolkit/antd-blocks/resourceTable/ResourceTableHeader';
+import { useFactory, useLifecycle } from '@brain-toolkit/react-kit';
+import { ResourceStore } from '@qlover/corekit-bridge';
+import { useMemo } from 'react';
+import { ResourceState } from '@/base/cases/ResourceState';
+import { ZodColumnBuilder } from '@/base/cases/ZodColumnBuilder';
+import { AdminUserApi } from '@/base/services/adminApi/AdminUserApi';
+import { AdminPageEvent } from '@/base/services/AdminPageEvent';
+import { ResourceService } from '@/base/services/ResourceService';
 import { ClientSeo } from '@/uikit/components/ClientSeo';
 import { useI18nInterface } from '@/uikit/hook/useI18nInterface';
 import { useIOC } from '@/uikit/hook/useIOC';
-import { useStore } from '@/uikit/hook/useStore';
-import { userSchema, type UserSchema } from '@migrations/schema/UserSchema';
-import { adminUsers18n } from '@config/i18n';
-import type { ColumnsType } from 'antd/es/table';
+import { useWarnTranslations } from '@/uikit/hook/useWarnTranslations';
+import { userSchema } from '@migrations/schema/UserSchema';
+import { adminUsers18n, adminTableI18n } from '@config/i18n';
 
-const baseColumns: ColumnsType<UserSchema> = Object.keys(
-  userSchema.omit({
-    password: true,
-    credential_token: true
-  }).shape
-).map((key) => ({
-  title: key,
-  dataIndex: key
-}));
+const ns = 'admin_users';
 
-export default function UsersPage() {
-  const adminUserService = useIOC(AdminUserService);
-  const tt = useI18nInterface(adminUsers18n);
-  const listParams = useStore(adminUserService, (state) => state.listParams);
-  const listState = useStore(adminUserService, (state) => state.listState);
-  const mouted = useRef(false);
+const localesTT = {
+  ...adminUsers18n,
+  ...adminTableI18n
+};
 
-  useEffect(() => {
-    if (!mouted.current) {
-      mouted.current = true;
+export default function UsersPage() {
+  const tt = useI18nInterface(localesTT);
+  const t = useWarnTranslations();
+  const adminUserApi = useIOC(AdminUserApi);
+  const resourceStore = useFactory(ResourceStore, () => new ResourceState());
+  const service = useFactory(ResourceService, ns, resourceStore, adminUserApi);
+  const pageEvent = useFactory(AdminPageEvent, ns, service);
 
-      requestAnimationFrame(() => {
-        adminUserService.initialize();
-      });
-    }
-  }, [adminUserService]);
+  const zodColumnBuilder = useFactory(
+    ZodColumnBuilder,
+    ns,
+    userSchema.omit({
+      password: true,
+      credential_token: true
+    })
+  );
 
-  const dataSource = listState.result?.list as UserSchema[];
+  useLifecycle(pageEvent);
 
-  const columns: ColumnsType<UserSchema> = baseColumns;
+  const options = useMemo(
+    () => zodColumnBuilder.translate(t).buildAll(),
+    [t, zodColumnBuilder]
+  );
 
   return (
     <div data-testid="UsersPage">
       <ClientSeo i18nInterface={tt} />
-      <Table
-        rowKey="id"
-        columns={columns}
-        dataSource={dataSource}
-        loading={listState.loading}
-        scroll={{ x: true }}
-        pagination={{
-          pageSizeOptions: [10, 20, 50],
-          current: listParams.page,
-          pageSize: listParams.pageSize,
-          total: listState.result?.total,
-          onChange: (page, pageSize) => {
-            adminUserService.changeListParams({
-              page,
-              pageSize
-            });
-          }
-        }}
+
+      <ResourceTableHeader
+        settings={Object.assign({}, tt, { create: false })}
+        tableEvent={pageEvent}
+      />
+
+      <ResourceTable
+        columns={options}
+        tableEvent={pageEvent}
+        actionProps={false}
       />
     </div>
   );

package/dist/templates/next-app/src/app/[locale]/login/LoginForm.tsx

@@ -2,11 +2,11 @@
 
 import { UserOutlined, LockOutlined, GoogleOutlined } from '@ant-design/icons';
 import { Form, Input, Button } from 'antd';
-import { useTranslations } from 'next-intl';
 import { useState } from 'react';
 import { LoginValidator } from '@/server/validators/LoginValidator';
 import { LocaleLink } from '@/uikit/components/LocaleLink';
 import { useIOC } from '@/uikit/hook/useIOC';
+import { useWarnTranslations } from '@/uikit/hook/useWarnTranslations';
 import type { LoginI18nInterface } from '@config/i18n/loginI18n';
 import { I } from '@config/IOCIdentifier';
 
@@ -17,7 +17,7 @@ interface LoginFormData {
 
 export function LoginForm(props: { tt: LoginI18nInterface }) {
   const { tt } = props;
-  const t = useTranslations();
+  const t = useWarnTranslations();
   const userService = useIOC(I.UserServiceInterface);
   const logger = useIOC(I.Logger);
   const appConfig = useIOC(I.AppConfig);

package/dist/templates/next-app/src/app/api/admin/locales/create/route.ts

@@ -0,0 +1,34 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse } from 'next/server';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { AppErrorApi } from '@/server/AppErrorApi';
+import { AppSuccessApi } from '@/server/AppSuccessApi';
+import { AdminAuthPlugin } from '@/server/services/AdminAuthPlugin';
+import { ApiLocaleService } from '@/server/services/ApiLocaleService';
+import { LocalesValidator } from '@/server/validators/LocalesValidator';
+import type { NextRequest } from 'next/server';
+
+export async function POST(req: NextRequest) {
+  const server = new BootstrapServer();
+
+  const result = await server
+    .use(new AdminAuthPlugin())
+    .execNoError(async ({ parameters: { IOC } }) => {
+      const requestBody = await req.json();
+      const localesParams = IOC(LocalesValidator).getThrow(requestBody);
+      const adminLocalesService = IOC(ApiLocaleService);
+      await adminLocalesService.create(localesParams);
+      return {
+        success: true
+      };
+    });
+
+  if (result instanceof ExecutorError) {
+    console.error(result);
+    return NextResponse.json(new AppErrorApi(result.id, result.message), {
+      status: 400
+    });
+  }
+
+  return NextResponse.json(new AppSuccessApi(result));
+}

package/dist/templates/next-app/src/app/api/admin/locales/import/route.ts

@@ -0,0 +1,40 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse } from 'next/server';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { AppErrorApi } from '@/server/AppErrorApi';
+import { AppSuccessApi } from '@/server/AppSuccessApi';
+import { AdminAuthPlugin } from '@/server/services/AdminAuthPlugin';
+import { ApiLocaleService } from '@/server/services/ApiLocaleService';
+import { LocalesImportValidator } from '@/server/validators/LocalesValidator';
+import type { NextRequest } from 'next/server';
+
+export async function POST(req: NextRequest) {
+  const server = new BootstrapServer();
+
+  const result = await server
+    .use(new AdminAuthPlugin())
+    .execNoError(async ({ parameters: { IOC } }) => {
+      const formData = await req.formData();
+
+      const localesParams = await IOC(LocalesImportValidator).getThrow({
+        values: formData
+      });
+
+      const adminLocalesService = IOC(ApiLocaleService);
+
+      const result = await adminLocalesService.importLocales(localesParams);
+      return {
+        success: true,
+        data: result
+      };
+    });
+
+  if (result instanceof ExecutorError) {
+    console.error(result);
+    return NextResponse.json(new AppErrorApi(result.id, result.message), {
+      status: 400
+    });
+  }
+
+  return NextResponse.json(new AppSuccessApi(result));
+}

package/dist/templates/next-app/src/app/api/admin/locales/route.ts

@@ -0,0 +1,42 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse } from 'next/server';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { AppErrorApi } from '@/server/AppErrorApi';
+import { AppSuccessApi } from '@/server/AppSuccessApi';
+import { AdminAuthPlugin } from '@/server/services/AdminAuthPlugin';
+import { ApiLocaleService } from '@/server/services/ApiLocaleService';
+import { PaginationValidator } from '@/server/validators/PaginationValidator';
+import type { NextRequest } from 'next/server';
+
+export async function GET(req: NextRequest) {
+  const server = new BootstrapServer();
+
+  const result = await server
+    .use(new AdminAuthPlugin())
+    .execNoError(async ({ parameters: { IOC } }) => {
+      const searchParams = Object.fromEntries(
+        req.nextUrl.searchParams.entries()
+      );
+
+      const paginationParams = IOC(PaginationValidator).getThrow(searchParams);
+
+      const apiUserService = IOC(ApiLocaleService);
+
+      const result = await apiUserService.getLocales({
+        page: paginationParams.page,
+        pageSize: paginationParams.pageSize,
+        orderBy: paginationParams.orders
+      });
+
+      return result;
+    });
+
+  if (result instanceof ExecutorError) {
+    console.error(result);
+    return NextResponse.json(new AppErrorApi(result.id, result.message), {
+      status: 400
+    });
+  }
+
+  return NextResponse.json(new AppSuccessApi(result));
+}

package/dist/templates/next-app/src/app/api/admin/locales/update/route.ts

@@ -0,0 +1,32 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse } from 'next/server';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { AppErrorApi } from '@/server/AppErrorApi';
+import { AppSuccessApi } from '@/server/AppSuccessApi';
+import { AdminAuthPlugin } from '@/server/services/AdminAuthPlugin';
+import { ApiLocaleService } from '@/server/services/ApiLocaleService';
+import type { NextRequest } from 'next/server';
+
+export async function POST(req: NextRequest) {
+  const server = new BootstrapServer();
+
+  const result = await server
+    .use(new AdminAuthPlugin())
+    .execNoError(async ({ parameters: { IOC } }) => {
+      const requestBody = await req.json();
+      const adminLocalesService = IOC(ApiLocaleService);
+      await adminLocalesService.update(requestBody);
+      return {
+        success: true
+      };
+    });
+
+  if (result instanceof ExecutorError) {
+    console.error(result);
+    return NextResponse.json(new AppErrorApi(result.id, result.message), {
+      status: 400
+    });
+  }
+
+  return NextResponse.json(new AppSuccessApi(result));
+}

package/dist/templates/next-app/src/app/api/locales/json/route.ts

@@ -0,0 +1,44 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse, type NextRequest } from 'next/server';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { ApiLocaleService } from '@/server/services/ApiLocaleService';
+import { i18nConfig } from '@config/i18n';
+import type { LocaleType } from '@config/i18n';
+
+export const revalidate = i18nConfig.localeCacheTime;
+
+export async function GET(req: NextRequest) {
+  const searchParams = Object.fromEntries(req.nextUrl.searchParams.entries());
+  const locale = searchParams.locale as LocaleType;
+
+  if (!locale || !i18nConfig.supportedLngs.includes(locale)) {
+    return NextResponse.json({}, { status: 404 });
+  }
+
+  const server = new BootstrapServer();
+
+  const result = await server.execNoError(async ({ parameters: { IOC } }) => {
+    const localesService = IOC(ApiLocaleService);
+    const result = await localesService.getLocalesJson(locale);
+
+    return result;
+  });
+
+  if (result instanceof ExecutorError) {
+    console.error(result);
+    return NextResponse.json(
+      {},
+      {
+        status: 400
+      }
+    );
+  }
+
+  const response = NextResponse.json(result);
+  response.headers.set(
+    'Cache-Control',
+    `s-maxage=${i18nConfig.localeCacheTime}`
+  );
+  response.headers.set('x-cache-tag', `i18n-${locale}`);
+  return response;
+}

package/dist/templates/next-app/src/base/cases/AdminPageManager.ts

@@ -1,23 +1,11 @@
 import { injectable } from 'inversify';
+import { defaultNavItems } from '@config/adminNavs';
 import { AdminLayoutInterface } from '../port/AdminLayoutInterface';
 import type {
   NavItemInterface,
   AdminPageState
 } from '../port/AdminLayoutInterface';
 
-const defaultNavItems: NavItemInterface[] = [
-  {
-    key: 'dashboard',
-    i18nKey: 'Dashboard',
-    pathname: '/admin'
-  },
-  {
-    key: 'users',
-    i18nKey: 'User Management',
-    pathname: '/admin/users'
-  }
-];
-
 class AdminPageManagerState implements AdminPageState {
   collapsedSidebar = false;
 

package/dist/templates/next-app/src/base/cases/Datetime.ts

@@ -0,0 +1,18 @@
+import dayjs from 'dayjs';
+import { injectable } from 'inversify';
+
+@injectable()
+export class Datetime {
+  timestamp(): number {
+    return dayjs().unix();
+  }
+
+  timestampz(): string {
+    const now = new Date();
+    return now.toISOString().replace('T', ' ').replace('Z', '+00');
+  }
+
+  format(format: string, date?: Date): string {
+    return dayjs(date).format(format);
+  }
+}

package/dist/templates/next-app/src/base/cases/DialogErrorPlugin.ts

@@ -4,8 +4,11 @@ import {
   type ExecutorPlugin
 } from '@qlover/fe-corekit';
 import { inject, injectable } from 'inversify';
+import { i18nKeySchema } from '@config/i18n/i18nKeyScheam';
+import { API_NOT_AUTHORIZED } from '@config/Identifier';
 import { I } from '@config/IOCIdentifier';
 import type { DialogHandlerOptions } from './DialogHandler';
+import type { RouterService } from './RouterService';
 import type { I18nServiceInterface } from '../port/I18nServiceInterface';
 import type { UIDialogInterface } from '@qlover/corekit-bridge';
 
@@ -16,7 +19,9 @@ export class DialogErrorPlugin implements ExecutorPlugin {
   constructor(
     @inject(I.DialogHandler)
     protected dialogHandler: UIDialogInterface<DialogHandlerOptions>,
-    @inject(I.I18nServiceInterface) protected i18nService: I18nServiceInterface
+    @inject(I.I18nServiceInterface) protected i18nService: I18nServiceInterface,
+    @inject(I.RouterServiceInterface)
+    protected routerService: RouterService
   ) {}
 
   onError(context: ExecutorContext<unknown>): void | Promise<void> {
@@ -28,9 +33,13 @@ export class DialogErrorPlugin implements ExecutorPlugin {
     const handleError = runtimesError || error;
 
     if (handleError instanceof ExecutorError) {
-      if (this.isI18nMessage(handleError.message)) {
+      if (this.isI18nMessage(handleError.id)) {
         const message = this.i18nService.t(handleError.id);
         this.dialogHandler.error(message);
+
+        if (handleError.id === API_NOT_AUTHORIZED) {
+          this.routerService.gotoLogin();
+        }
       } else {
         this.dialogHandler.error(handleError.message);
       }
@@ -38,9 +47,6 @@ export class DialogErrorPlugin implements ExecutorPlugin {
   }
 
   protected isI18nMessage(message: string): boolean {
-    // Check if message follows the pattern of underscore-separated format
-    // e.g., "namespace_key" or "namespace__key"
-    const pattern = /^[a-zA-Z]+(?:_[a-zA-Z]+)+$|^[a-zA-Z]+(?:__[a-zA-Z]+)+$/;
-    return pattern.test(message);
+    return i18nKeySchema.safeParse(message).success;
   }
 }

package/dist/templates/next-app/src/base/cases/ResourceState.ts

@@ -0,0 +1,17 @@
+import { RequestState } from '@qlover/corekit-bridge';
+import type { PaginationInterface } from '@/server/port/PaginationInterface';
+import type {
+  ResourceQuery,
+  ResourceStateInterface
+} from '@qlover/corekit-bridge';
+
+export class ResourceState implements ResourceStateInterface {
+  searchParams: ResourceQuery = {
+    page: 1,
+    pageSize: 10,
+    orderBy: 'updated_at',
+    order: 1
+  };
+  initState = new RequestState<unknown>();
+  listState = new RequestState<PaginationInterface<unknown>>();
+}

package/dist/templates/next-app/src/base/cases/TranslateI18nInterface.ts

@@ -0,0 +1,25 @@
+import type { PageI18nInterface } from '@config/i18n';
+import type { useTranslations } from 'next-intl';
+
+/**
+ * Translate I18n Interface tools class
+ *
+ * @param i18nInterface - The i18n interface to translate
+ * @param t - The translations function
+ * @returns The translated i18n interface
+ */
+export class TranslateI18nInterface {
+  static translate<T extends PageI18nInterface | Record<string, string>>(
+    source: T,
+    t: ReturnType<typeof useTranslations>
+  ): T {
+    return Object.fromEntries(
+      Object.entries(source).map(([key, value]) => {
+        if (typeof value === 'string') {
+          return [key, t(value)];
+        }
+        return [key, value];
+      })
+    ) as T;
+  }
+}

package/dist/templates/next-app/src/base/cases/ZodColumnBuilder.ts

@@ -0,0 +1,200 @@
+import { ResourceTableFormMap } from '@brain-toolkit/antd-blocks';
+import { merge } from 'lodash';
+import {
+  type z,
+  ZodFirstPartyTypeKind,
+  type ZodObject,
+  type ZodRawShape,
+  type ZodType
+} from 'zod';
+import { joinI18nKey } from '@config/i18n/i18nKeyScheam';
+import type { ZodBuilderInterface } from '../port/ZodBuilderInterface';
+import type {
+  ResourceTableFormType,
+  ResourceTableOption
+} from '@brain-toolkit/antd-blocks';
+import type { NamePath } from 'antd/es/form/interface';
+import type { useTranslations } from 'next-intl';
+
+type OptionMap<
+  Value extends ZodRawShape,
+  Input extends ZodObject<Value>
+> = Record<keyof Input['shape'], ResourceTableOption<z.infer<Input>>>;
+
+export const ZodType2RenderFormMap = {
+  [ZodFirstPartyTypeKind.ZodString]: ResourceTableFormMap.input,
+  [ZodFirstPartyTypeKind.ZodNumber]: ResourceTableFormMap.input,
+  [ZodFirstPartyTypeKind.ZodBigInt]: ResourceTableFormMap.input,
+  [ZodFirstPartyTypeKind.ZodBoolean]: ResourceTableFormMap.select,
+  [ZodFirstPartyTypeKind.ZodEnum]: ResourceTableFormMap.select,
+  [ZodFirstPartyTypeKind.ZodNativeEnum]: ResourceTableFormMap.select
+} as const;
+
+export class ZodColumnBuilder<
+  Value extends ZodRawShape,
+  Input extends ZodObject<Value>
+> implements ZodBuilderInterface<Input, ResourceTableOption<z.infer<Input>>>
+{
+  protected optionMap: OptionMap<Value, Input>;
+
+  constructor(
+    readonly namespace: string,
+    readonly input: Input,
+    optionMap?: OptionMap<Value, Input>
+  ) {
+    const baseOptions = this.getBaseOptions(input);
+    this.optionMap = optionMap ? merge(baseOptions, optionMap) : baseOptions;
+  }
+
+  static zodType2RenderForm(zod: ZodType): ResourceTableFormType | undefined {
+    // @ts-expect-error - zod._def.typeName is not typed
+    const typeName = zod._def?.typeName as ZodFirstPartyTypeKind;
+
+    // Handle wrapper types (Optional, Nullable, Default)
+    if (
+      typeName === ZodFirstPartyTypeKind.ZodOptional ||
+      typeName === ZodFirstPartyTypeKind.ZodNullable ||
+      typeName === ZodFirstPartyTypeKind.ZodDefault
+    ) {
+      // @ts-expect-error - innerType is not typed
+      return ZodColumnBuilder.zodType2RenderForm(zod._def.innerType);
+    }
+
+    // Direct mapping lookup
+    return ZodType2RenderFormMap[
+      typeName as keyof typeof ZodType2RenderFormMap
+    ];
+  }
+
+  zod2BaseOption(
+    key: string,
+    zod: ZodType
+  ): ResourceTableOption<z.infer<Input>> {
+    return {
+      key: key,
+      title: key,
+      dataIndex: key,
+      tt: {
+        tableTitle: joinI18nKey(this.namespace, key, 'title'),
+        description: joinI18nKey(this.namespace, key, 'description'),
+        formItemLabel: joinI18nKey(this.namespace, key, 'label'),
+        formItemPlaceholder: joinI18nKey(this.namespace, key, 'placeholder'),
+        formItemError: joinI18nKey(this.namespace, key, 'error'),
+        formItemRequired: joinI18nKey(this.namespace, key, 'required')
+      },
+      renderForm: ZodColumnBuilder.zodType2RenderForm(zod),
+      formItemWrapProps: {
+        name: key as NamePath<z.infer<Input>>,
+        label: key,
+        rules: []
+      },
+      formItemProps: {}
+    };
+  }
+
+  getBaseOptions(input: Input): OptionMap<Value, Input> {
+    return Object.entries(input.shape).reduce(
+      (acc, [key, zod]) => {
+        acc[key as keyof Input['shape']] = this.zod2BaseOption(
+          key,
+          zod as ZodType
+        );
+        return acc;
+      },
+      {} as OptionMap<Value, Input>
+    );
+  }
+
+  bind(
+    key: keyof Input['shape'],
+    params?: Partial<ResourceTableOption<z.infer<Input>>>
+  ): this {
+    if (params) {
+      const existingOption = this.optionMap[key];
+      this.optionMap[key] = merge({}, existingOption, params);
+    }
+    return this;
+  }
+
+  render<K extends keyof Input['shape']>(
+    key: K,
+    render: (
+      value: unknown,
+      record: z.infer<Input>,
+      index: number
+    ) => React.ReactNode
+  ): this {
+    this.optionMap[key].render = render;
+    return this;
+  }
+
+  /**
+   * Translate all i18n keys in options to actual text
+   * @param t - Translation function from next-intl
+   * @returns this for chaining
+   */
+  translate(t: ReturnType<typeof useTranslations>): this {
+    Object.values(this.optionMap).forEach((option) => {
+      const { tt } = option;
+      // Translate title if it's a string (i18n key)
+      if (typeof option.title === 'string') {
+        option.title = t(tt.tableTitle);
+      }
+
+      // Translate formItemWrapProps label if exists
+      if (
+        option.formItemWrapProps?.label &&
+        typeof option.formItemWrapProps.label === 'string'
+      ) {
+        option.formItemWrapProps = {
+          ...option.formItemWrapProps,
+          label: t(tt.formItemLabel)
+        };
+      }
+
+      // Translate formItemProps placeholder if exists
+      if (option.formItemProps && typeof option.formItemProps === 'object') {
+        Object.assign(
+          option.formItemProps as Record<string, unknown>,
+          {
+            placeholder: t(tt.formItemPlaceholder)
+          } as Record<string, unknown>
+        );
+      }
+    });
+
+    return this;
+  }
+
+  /**
+   * Build a single option by key
+   * @param key - The key of the option to build
+   * @param params - Optional additional parameters to merge
+   * @returns The built option
+   */
+  build(key: string, params?: unknown): ResourceTableOption<z.infer<Input>> {
+    const option = this.optionMap[key as keyof Input['shape']];
+    if (!option) {
+      throw new Error(`Option with key "${key}" not found`);
+    }
+
+    if (params && typeof params === 'object') {
+      return merge(
+        {},
+        option,
+        params as Partial<ResourceTableOption<z.infer<Input>>>
+      );
+    }
+
+    return option;
+  }
+
+  /**
+   * Build all options
+   * @param params - Optional additional parameters (currently unused)
+   * @returns Array of all built options
+   */
+  buildAll(_params?: unknown): ResourceTableOption<z.infer<Input>>[] {
+    return Object.values(this.optionMap);
+  }
+}

package/dist/templates/next-app/src/base/port/ZodBuilderInterface.ts

@@ -0,0 +1,8 @@
+export interface ZodBuilderInterface<Input, Ouput> {
+  readonly input: Input;
+
+  bind(key: string, params?: Partial<Ouput>): this;
+
+  build(key: string, params?: unknown): Ouput;
+  buildAll(params?: unknown): Ouput[];
+}