wabe 0.6.8 → 0.6.10

package/README.md

@@ -1,32 +1,63 @@
 <p align="center">
-  <a href="https://wabe.dev"><img src="https://wabe.dev/assets/logo.png" alt="Wabe logo" height=170></a>
+  <h1 align="center">Wabe</h1>
+  <p align="center">🚀 A fully open-source <strong>Firebase alternative</strong> built in TypeScript</p>
 </p>
 
-<div align="center">
-  <a href="https://wabe.dev">Documentation</a>
-</div>
+<p align="center">
+  <a href="https://github.com/palixir/wabe"><img src="https://img.shields.io/github/stars/palixir/wabe?style=flat-square" /></a>
+  <a href="https://www.npmjs.com/package/wabe"><img src="https://img.shields.io/npm/v/wabe?style=flat-square" /></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-green?style=flat-square" /></a>
+</p>
+
+---
+
+Wabe is a modern, batteries-included backend-as-a-service designed for developers who want the flexibility of self-hosting with the ease of Firebase.
+
+You define your models → Wabe instantly generates:
+- a **secure GraphQL API**
+- **auth**, **permissions**, **hooks**, **emails**, **files**, and more
+- a fully extensible backend written in clean TypeScript
+
+No vendor lock-in. No hidden limits.  
+Host it anywhere.
+
+📚 **Documentation:** [https://palixir.github.io/wabe](https://palixir.github.io/wabe)
+
+---
 
-## What is Wabe?
+# ✨ Features
 
-Wabe is an open-source backend as a service that allows you to create your own fully customizable backend in just a few minutes. It handles database access, automatic GraphQL API generation, authentication with various methods (classic or OAuth), permissions, security, emails, and more for you.
+| Feature                  | Description                                                                 |
+|--------------------------|-----------------------------------------------------------------------------|
+| 🔐 Authentication        | Email/password, OTP, OAuth (Google, GitHub), password reset, email verification |
+| 🔑 Permissions           | Fine-grained access control at collection, object, and field levels with secure defaults |
+| ⚡ Auto-generated GraphQL | Fully typed CRUD GraphQL API generated from your schema, ready for production |
+| 🔄 Hooks                  | Custom logic before/after create, update, delete, and read operations      |
+| 📨 Email providers        | Resend (official adapter) or custom adapters                                |
+| 🗄️ Database adapters      | MongoDB, PostgreSQL (official), or your own adapter                          |
+| 📦 Modular architecture   | Replaceable and extensible modules: auth, storage, email, database, permissions |
+| 🌍 Self-host anywhere     | Docker, Node, Bun, Fly.io, Render, Railway, Hetzner, Raspberry Pi           |
 
-## Install
 
-```sh
-bun install wabe # On bun
-npm install wabe # On npm
-yarn add wabe # On yarn
+---
+
+# 🚀 Quickstart
+
+### 1. Install
+
+```bash
+npm install wabe
+# or
+bun add wabe
 ```
 
-## Basic example
+### 2. Create your schema and start your server
 
-```ts
+``` ts
 import { Wabe } from "wabe";
 import { MongoAdapter } from "wabe-mongodb";
 
 const run = async () => {
-  // Ensure your database is running before run the file
-
   const wabe = new Wabe({
     isProduction: process.env.NODE_ENV === "production",
     // Root key example (must be long minimal 64 characters, you can generate it online)
@@ -35,10 +66,30 @@ const run = async () => {
     database: {
       adapter: new MongoAdapter({
         databaseName: "WabeApp",
-        url: "mongodb://127.0.0.1:27045",
+        databaseUrl: "mongodb://127.0.0.1:27045",
       }),
     },
-    port: 3001,
+    schema: {
+      classes: [
+        {
+          name: 'User',
+          description: 'User class',
+          fields: {
+            name: {
+              type: 'String',
+            },
+            age: {
+              type: 'Int',
+            },
+            email: {
+              type: 'Email',
+              required: true,
+            },
+          },
+        },
+      ]
+    },
+    port: 3000,
   });
 
   await wabe.start();
@@ -47,27 +98,84 @@ const run = async () => {
 await run();
 ```
 
-## Features
+### 3. Query your API
+
+``` graphql
+mutation createUser {
+  createUser(input: { fields: {name: "Wabe", email: "mybackend@wabe.com", age: 10} }) {
+      user {
+        id
+        name
+      }
+  }
+}
+```
+
+
+# 🧩 Official Templates
+
+Wabe comes with a set of official templates to help you bootstrap projects instantly:
+
+| Template               | Stack          | Description                     | Status         |
+|------------------------|----------------|---------------------------------|----------------|
+| **wabe-starter**       | Wabe + Node    | Minimal starter backend         | 🟡 Coming soon   |
+| **wabe-next-template** | Next.js + Wabe | Authentication + CRUD boilerplate | 🟡 Coming soon |
+| **wabe-saas-kit**      | Wabe + Wobe    | SaaS starter kit with Stripe    | 🟡 Coming soon |
+
+More templates are added regularly based on community needs.
+
+---
+
+# 🌱 Ecosystem
+
+### **Wobe — Full-stack web framework**
+
+Wobe is a lightweight, TypeScript-first full-stack framework designed to pair naturally with Wabe.  
+For a seamless frontend + backend developer experience:
+
+👉 https://github.com/palixir/wobe
+
+### **GraphQL Server (coming soon)**
+
+A modern, type-safe GraphQL server designed as a companion to Wabe.  
+Optimized for DX, performance, and full extensibility.
+
+---
+
+# 🗺️ Roadmap
+
+- [x] PostgreSQL adapter  
+- [ ] Admin dashboard UI  
+- [x] File storage adapters (S3, Cloudflare R2, etc.)  
+- [ ] CLI (`wabe init`, `wabe generate`)  
+- [ ] SaaS starter kit  
+- [ ] Improved documentation  
+
+---
+
+# 🤝 Contributing
+
+Contributions are welcome!  
+Before opening a PR, check the `CONTRIBUTING.md` and join the community.
 
-- **Authentication**: Secure and scalable authentication for your applications.
-- **Permissions**: Granular permissions control to secure your resources.
-- **Database**: A powerful, scalable database to store and manage you data.
-- **GraphQL API**: A flexible and powerful GraphQL API (following GraphQL Relay standard) to interact with your data.
-- **Hooks**: Powerful hooks system to execute custom actions before or after database requests.
-- **Email**: Send emails with your favorite provider with very simple integration.
+---
 
-## Contributing
+# ❤️ Sponsors
 
-Contributions are always welcome! If you have an idea for something that should be added, modified, or removed, please don't hesitate to create a pull request (I promise a quick review).
+Wabe is 100% open-source and maintained in my free time.  
+If you want to support development:
 
-You can also create an issue to propose your ideas or report a bug.
+👉 **GitHub Sponsors:** https://github.com/sponsors/coratgerl  
 
-Of course, you can also use Wabe for your backend; that is the better contribution at this day ❤️.
+**Sponsors receive:**  
+- Access to a complete, fully tested boilerplate with an admin dashboard to manage users (Vite, Tailwind, Playwright, Wabe, Bun, GraphQL, etc.)  
+- Your name featured in the `README.md`  
 
-If you like the project don't forget to share it.
+Your support helps keep Wabe sustainable and actively maintained, and allows me to continue creating new projects in my free time to help developers have solid backends with minimal effort.
 
-More information on the [Contribution guide](https://github.com/palixir/wabe/blob/main/CONTRIBUTING.md)
+---
 
-## License
+# ⭐ Show your support
 
-Distributed under the Apache License 2.0 [License](https://github.com/palixir/wabe/blob/main/LICENSE).
+If you like the project, please consider starring the repository:
+⭐ → It helps more than you think.

package/dev/index.ts

@@ -0,0 +1,215 @@
+import {
+	RoleEnum,
+	type WabeSchemaWhereTypes,
+	type WabeSchemaEnums,
+	type WabeSchemaScalars,
+	type WabeSchemaTypes,
+} from '../generated/wabe'
+import { getDatabaseAdapter } from '../src/utils/testHelper'
+import { Wabe } from '../src/server'
+import { FileDevAdapter } from '../src'
+import { runDatabase } from 'wabe-mongodb-launcher'
+
+const run = async () => {
+	await runDatabase()
+
+	const wabe = new Wabe<{
+		types: WabeSchemaTypes
+		scalars: WabeSchemaScalars
+		enums: WabeSchemaEnums
+		where: WabeSchemaWhereTypes
+	}>({
+		isProduction: false,
+		codegen: {
+			enabled: true,
+			path: `${import.meta.dirname}/../generated/`,
+		},
+		rootKey: 'dev',
+		authentication: {
+			session: {
+				cookieSession: true,
+				jwtSecret: 'dev',
+				jwtTokenFields: {
+					id: true,
+				},
+			},
+			roles: ['Admin', 'Client'],
+			successRedirectPath: 'https://palixir.github.io/wabe/',
+			failureRedirectPath: 'https://palixir.github.io/wabe/',
+		},
+		database: {
+			// @ts-expect-error
+			adapter: await getDatabaseAdapter('Wabe'),
+		},
+		file: {
+			adapter: new FileDevAdapter(),
+		},
+		port: 3001,
+		schema: {
+			classes: [
+				{
+					name: 'User',
+					description: 'User class',
+					fields: {
+						name: {
+							type: 'String',
+						},
+						age: {
+							type: 'Int',
+						},
+						email: {
+							type: 'Email',
+							required: true,
+						},
+					},
+				},
+				{
+					name: 'Post',
+					fields: {
+						name: { type: 'String', required: true },
+						test2: { type: 'RoleEnum' },
+						test3: { type: 'Relation', class: 'User', required: true },
+						test4: { type: 'Pointer', class: 'User', required: true },
+						experiences: {
+							type: 'Array',
+							typeValue: 'Object',
+							object: {
+								name: 'Experience',
+								required: true,
+								fields: {
+									jobTitle: {
+										type: 'String',
+										required: true,
+									},
+									companyName: {
+										type: 'String',
+										required: true,
+									},
+									startDate: {
+										type: 'String',
+										required: true,
+									},
+									endDate: {
+										type: 'String',
+										required: true,
+									},
+									achievements: {
+										type: 'Array',
+										typeValue: 'String',
+									},
+								},
+							},
+						},
+					},
+					permissions: {
+						create: {
+							requireAuthentication: true,
+							authorizedRoles: [RoleEnum.Admin],
+						},
+					},
+				},
+			],
+			resolvers: {
+				queries: {
+					helloWorld: {
+						type: 'String',
+						description: 'Hello world description',
+						args: {
+							name: {
+								type: 'String',
+								required: true,
+							},
+						},
+						resolve: () => 'Hello World',
+					},
+				},
+				mutations: {
+					createMutation: {
+						type: 'Boolean',
+						required: true,
+						args: {
+							input: {
+								name: {
+									type: 'Int',
+									required: true,
+								},
+							},
+						},
+						resolve: () => true,
+					},
+					customMutation: {
+						type: 'Int',
+						args: {
+							input: {
+								a: {
+									type: 'Int',
+									required: true,
+								},
+								b: {
+									type: 'Int',
+									required: true,
+								},
+							},
+						},
+						resolve: (_: any, args: any) => args.input.a + args.input.b,
+					},
+					secondCustomMutation: {
+						type: 'Int',
+						args: {
+							input: {
+								sum: {
+									type: 'Object',
+									object: {
+										name: 'Sum',
+										fields: {
+											a: {
+												type: 'Int',
+												required: true,
+											},
+											b: {
+												type: 'Int',
+												required: true,
+											},
+										},
+									},
+								},
+							},
+						},
+						resolve: (_: any, args: any) => args.input.sum.a + args.input.sum.b,
+					},
+				},
+			},
+		},
+	})
+
+	// For select test
+	// const res = await wabe.controllers.database.getObjects({
+	//   className: 'Post',
+	//   context: {} as any,
+	//   select: {
+	//     name: true,
+	//     test3: {
+	//       age: true,
+	//       role: {
+	//         id: true,
+	//       },
+	//     },
+	//     test4: {
+	//       name: true,
+	//     },
+	//   },
+	//   where: {
+	//     name: {
+	//       equalTo: 'test',
+	//     },
+	//   },
+	// })
+
+	// res[0]?.test3[0].role?.id
+
+	await wabe.start()
+}
+
+run().catch((err) => {
+	console.error(err)
+})

package/dist/authentication/OTP.d.ts

@@ -3,8 +3,11 @@ export declare class OTP {
 	private secret;
 	internalTotp: TOTP;
 	constructor(rootKey: string);
+	deriveSecret(userId: string): string;
 	generate(userId: string): string;
 	verify(otp: string, userId: string): boolean;
+	authenticatorGenerate(userId: string): string;
+	authenticatorVerify(otp: string, userId: string): boolean;
 	generateKeyuri({ userId, emailOrUsername, applicationName }: {
 		userId: string;
 		emailOrUsername: string;

package/dist/authentication/Session.d.ts

@@ -8,14 +8,17 @@ export declare class Session {
 	getAccessTokenExpireAt(config: WabeConfig<DevWabeTypes>);
 	_getRefreshTokenExpiresInMs(config: WabeConfig<DevWabeTypes>);
 	getRefreshTokenExpireAt(config: WabeConfig<DevWabeTypes>);
-	meFromAccessToken(accessToken: string, context: WabeContext<DevWabeTypes>): Promise<{
+	meFromAccessToken({ accessToken, csrfToken }: {
+		accessToken: string;
+		csrfToken: string;
+	}, context: WabeContext<DevWabeTypes>): Promise<{
 		sessionId: string | null;
 		user: User | null;
 		accessToken: string | null;
 		refreshToken?: string | null;
 	}>;
 	create(userId: string, context: WabeContext<DevWabeTypes>);
+	refresh(accessToken: string, refreshToken: string, context: WabeContext<DevWabeTypes>);
 	delete(context: WabeContext<DevWabeTypes>);
 	_isRefreshTokenExpired(userRefreshTokenExpiresAt: Date, refreshTokenAgeInMs: number);
-	refresh(accessToken: string, refreshToken: string, context: WabeContext<DevWabeTypes>);
 }

package/dist/authentication/interface.d.ts

@@ -2,6 +2,7 @@ import type { User } from "../../generated/wabe";
 import type { WabeContext } from "../server/interface";
 import type { SchemaFields } from "../schema";
 import type { WabeTypes, WobeCustomContext } from "../server";
+import type { SelectType } from "../database/interface";
 export declare enum ProviderEnum {
 	google = "google",
 	github = "github"
@@ -82,7 +83,7 @@ export type CustomAuthenticationMethods<
 	isSecondaryFactor?: boolean;
 };
 export type RoleConfig = Array<string>;
-export interface SessionConfig {
+export interface SessionConfig<T extends WabeTypes> {
 	/**
 	* The time in milliseconds that the access token will expire
 	*/
@@ -99,9 +100,29 @@ export interface SessionConfig {
 	* The JWT secret used to sign the session tokens
 	*/
 	jwtSecret: string;
+	/**
+	* Optional audience to embed and verify in JWTs
+	*/
+	jwtAudience?: string;
+	/**
+	* Optional issuer to embed and verify in JWTs
+	*/
+	jwtIssuer?: string;
+	/**
+	* Secret dedicated to CSRF token HMAC (defaults to jwtSecret)
+	*/
+	csrfSecret?: string;
+	/**
+	* Secret used to encrypt session tokens at rest (defaults to jwtSecret)
+	*/
+	tokenSecret?: string;
+	/**
+	* A selection of fields to include in the JWT token in the "user" fields
+	*/
+	jwtTokenFields?: SelectType<T, "User", keyof T["types"]["User"]>;
 }
 export interface AuthenticationConfig<T extends WabeTypes> {
-	session?: SessionConfig;
+	session?: SessionConfig<T>;
 	roles?: RoleConfig;
 	successRedirectPath?: string;
 	failureRedirectPath?: string;
@@ -129,5 +150,6 @@ export declare enum AuthenticationProvider {
 	PhonePassword = "phonePassword"
 }
 export declare enum SecondaryFactor {
-	EmailOTP = "emailOTP"
+	EmailOTP = "emailOTP",
+	QRCodeOTP = "qrcodeOTP"
 }

package/dist/authentication/utils.d.ts

@@ -5,4 +5,3 @@ export declare const getAuthenticationMethod: <
 	T extends WabeTypes,
 	U = ProviderInterface<T> | SecondaryProviderInterface<T>
 >(listOfMethods: string[], context: WabeContext<any>) => CustomAuthenticationMethods<T, U>;
-export declare const hashPassword: unknown;

package/dist/database/DatabaseController.d.ts

@@ -33,7 +33,7 @@ export declare class DatabaseController<T extends WabeTypes> {
 	});
 	_getWhereObjectWithPointerOrRelation<U extends keyof T["types"]>(className: U, where: WhereType<T, U>, context: WabeContext<T>);
 	_buildWhereWithACL<K extends keyof T["types"]>(where: WhereType<T, K>, context: WabeContext<T>, operation: "write" | "read"): WhereType<T, K>;
-	_getFinalObjectWithPointerAndRelation({ pointers, context, originClassName, object, isGraphQLCall }: {
+	_getFinalObjectWithPointerAndRelation({ pointers, context, originClassName, object, _skipHooks }: {
 		originClassName: string;
 		pointers: Record<string, {
 			className: string;
@@ -41,7 +41,7 @@ export declare class DatabaseController<T extends WabeTypes> {
 		}>;
 		context: WabeContext<any>;
 		object: Record<string, any>;
-		isGraphQLCall?: boolean;
+		_skipHooks?: boolean;
 	});
 	close();
 	createClassIfNotExist(className: string, schema: SchemaInterface<T>): Promise<any>;
@@ -51,42 +51,42 @@ export declare class DatabaseController<T extends WabeTypes> {
 	getObject<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K]
-	>({ select, className, context, skipHooks, id, where, isGraphQLCall }: GetObjectOptions<T, K, U>): Promise<OutputType<T, K, U>>;
+	>({ select, className, context, _skipHooks, id, where }: GetObjectOptions<T, K, U>): Promise<OutputType<T, K, U>>;
 	getObjects<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K]
-	>({ className, select, context, where, skipHooks, first, offset, order, isGraphQLCall }: GetObjectsOptions<T, K, U, W>): Promise<OutputType<T, K, W>[]>;
+	>({ className, select, context, where, _skipHooks, first, offset, order }: GetObjectsOptions<T, K, U, W>): Promise<OutputType<T, K, W>[]>;
 	createObject<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K]
-	>({ className, context, data, select, isGraphQLCall }: CreateObjectOptions<T, K, U, W>): Promise<OutputType<T, K, W>>;
+	>({ className, context, data, select }: CreateObjectOptions<T, K, U, W>): Promise<OutputType<T, K, W>>;
 	createObjects<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K],
 		X extends keyof T["types"][K]
-	>({ data, select, className, context, first, offset, order, isGraphQLCall }: CreateObjectsOptions<T, K, U, W, X>): Promise<OutputType<T, K, W>[]>;
+	>({ data, select, className, context, first, offset, order }: CreateObjectsOptions<T, K, U, W, X>): Promise<OutputType<T, K, W>[]>;
 	updateObject<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K]
-	>({ id, className, context, data, select, skipHooks, isGraphQLCall }: UpdateObjectOptions<T, K, U, W>): Promise<OutputType<T, K, W>>;
+	>({ id, className, context, data, select, _skipHooks }: UpdateObjectOptions<T, K, U, W>): Promise<OutputType<T, K, W>>;
 	updateObjects<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K],
 		X extends keyof T["types"][K]
-	>({ className, where, context, select, data, first, offset, order, skipHooks, isGraphQLCall }: UpdateObjectsOptions<T, K, U, W, X>): Promise<OutputType<T, K, W>[]>;
+	>({ className, where, context, select, data, first, offset, order, _skipHooks }: UpdateObjectsOptions<T, K, U, W, X>): Promise<OutputType<T, K, W>[]>;
 	deleteObject<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K]
-	>({ context, className, id, select, isGraphQLCall }: DeleteObjectOptions<T, K, U>): Promise<OutputType<T, K, U>>;
+	>({ context, className, id, select }: DeleteObjectOptions<T, K, U>): Promise<OutputType<T, K, U>>;
 	deleteObjects<
 		K extends keyof T["types"],
 		U extends keyof T["types"][K],
 		W extends keyof T["types"][K]
-	>({ className, context, select, where, first, offset, order, isGraphQLCall }: DeleteObjectsOptions<T, K, U, W>): Promise<OutputType<T, K, W>[]>;
+	>({ className, context, select, where, first, offset, order }: DeleteObjectsOptions<T, K, U, W>): Promise<OutputType<T, K, W>[]>;
 }
 export {};

package/dist/database/interface.d.ts

@@ -95,9 +95,8 @@ export interface GetObjectOptions<
 	id: string;
 	where?: WhereType<T, K>;
 	context: WabeContext<T>;
-	skipHooks?: boolean;
+	_skipHooks?: boolean;
 	select?: SelectType<T, K, U>;
-	isGraphQLCall?: boolean;
 }
 export interface GetObjectsOptions<
 	T extends WabeTypes,
@@ -111,9 +110,8 @@ export interface GetObjectsOptions<
 	offset?: number;
 	first?: number;
 	context: WabeContext<T>;
-	skipHooks?: boolean;
+	_skipHooks?: boolean;
 	select?: SelectType<T, K, W>;
-	isGraphQLCall?: boolean;
 }
 export interface CreateObjectOptions<
 	T extends WabeTypes,
@@ -125,7 +123,6 @@ export interface CreateObjectOptions<
 	data: MutationData<T, K, U>;
 	context: WabeContext<T>;
 	select?: SelectType<T, K, W>;
-	isGraphQLCall?: boolean;
 }
 export interface CreateObjectsOptions<
 	T extends WabeTypes,
@@ -141,7 +138,6 @@ export interface CreateObjectsOptions<
 	order?: OrderType<T, U, X>;
 	context: WabeContext<T>;
 	select?: SelectType<T, K, W>;
-	isGraphQLCall?: boolean;
 }
 export interface UpdateObjectOptions<
 	T extends WabeTypes,
@@ -154,9 +150,8 @@ export interface UpdateObjectOptions<
 	where?: WhereType<T, K>;
 	data: MutationData<T, K, U>;
 	context: WabeContext<T>;
-	skipHooks?: boolean;
+	_skipHooks?: boolean;
 	select?: SelectType<T, K, W>;
-	isGraphQLCall?: boolean;
 }
 export interface UpdateObjectsOptions<
 	T extends WabeTypes,
@@ -172,9 +167,8 @@ export interface UpdateObjectsOptions<
 	offset?: number;
 	first?: number;
 	context: WabeContext<T>;
-	skipHooks?: boolean;
+	_skipHooks?: boolean;
 	select?: SelectType<T, K, W>;
-	isGraphQLCall?: boolean;
 }
 export interface DeleteObjectOptions<
 	T extends WabeTypes,
@@ -186,7 +180,6 @@ export interface DeleteObjectOptions<
 	where?: WhereType<T, K>;
 	context: WabeContext<T>;
 	select?: SelectType<T, K, U>;
-	isGraphQLCall?: boolean;
 }
 export interface DeleteObjectsOptions<
 	T extends WabeTypes,
@@ -201,11 +194,10 @@ export interface DeleteObjectsOptions<
 	first?: number;
 	context: WabeContext<T>;
 	select?: SelectType<T, K, W>;
-	isGraphQLCall?: boolean;
 }
 export interface DatabaseAdapter<T extends WabeTypes> {
 	close(): Promise<void>;
-	createClassIfNotExist(className: string, schema: SchemaInterface<T>): Promise<any>;
+	createClassIfNotExist(className: string, schema: SchemaInterface<T>): Promise<any> | any;
 	initializeDatabase(schema: SchemaInterface<T>): Promise<void>;
 	clearDatabase(): Promise<void>;
 	count<K extends keyof T["types"]>(params: CountOptions<T, K>): Promise<number>;

package/dist/email/interface.d.ts

@@ -10,7 +10,7 @@ export interface EmailSendOptions {
 	from: string;
 	to: Array<string>;
 	subject: string;
-	node?: React.ReactNode;
+	node?: any;
 	html?: string;
 	text?: string;
 }