@duplojs/agents-kit 0.0.0-stage → 0.1.0-beta.10

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/book/facts/create.ts

@@ -0,0 +1,33 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { Book } from "..";
+import * as DCommon from "@duplojs/lang/common";
+
+export const CreateBookFact = DModeling.createFact<
+	"CreateBook",
+	{
+		id: Book.Id;
+		title: Book.Title;
+		state: Book.AvailableState;
+	},
+	typeof Book.Entity
+>("CreateBook")(
+	({ applyFact }) => (
+		params: {
+			id: Book.Id;
+			title: Book.Title;
+		},
+	) => {
+		const payload = {
+			id: params.id,
+			title: params.title,
+			state: Book.AvailableState.new({}),
+		};
+
+		return DCommon.pipe(
+			Book.Entity.new(payload),
+			Book.AvailableFlag.append(payload.state),
+			applyFact(payload),
+		);
+	},
+);
+export type CreateBookFact = DModeling.GetFact<typeof CreateBookFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/book/facts/index.ts

@@ -0,0 +1,5 @@
+export * from "./create";
+export * from "./rental";
+export * from "./returnBook";
+export * from "./reserve";
+export * from "./withdraw";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/book/facts/rental.ts

@@ -0,0 +1,31 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { type Client } from "../../client";
+import { Book } from "..";
+import * as DCommon from "@duplojs/lang/common";
+
+export const BookRentalFact = DModeling.createFact<
+	"BookRental",
+	Book.BorrowedState,
+	typeof Book.Entity
+>("BookRental")(
+	({ applyFact }) => (
+		params: {
+			client: Client.Entity & Client.CanRentBookFlag;
+			book: Book.Entity & Book.AvailableFlag;
+		},
+	) => {
+		const borrowedState = Book.BorrowedState.new({
+			currentBorrowerId: params.client.id,
+		});
+
+		return DCommon.pipe(
+			params.book,
+			Book.Entity.update({
+				state: borrowedState,
+			}),
+			Book.BorrowedFlag.append(borrowedState),
+			applyFact(borrowedState),
+		);
+	},
+);
+export type BookRentalFact = DModeling.GetFact<typeof BookRentalFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/book/facts/reserve.ts

@@ -0,0 +1,37 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { Book } from "..";
+import { type Client } from "../../client";
+import { type WaitingListEntry } from "../../waitingListEntry";
+
+export const ReserveBookFact = DModeling.createFact<
+	"ReserveBook",
+	{
+		waitingListEntryId: WaitingListEntry.Id;
+		clientId: Client.Id;
+	},
+	typeof Book.Entity
+>("ReserveBook")(
+	({ applyFact }) => (
+		params: {
+			book: Book.Entity & Book.AvailableFlag;
+			waitingListEntry: WaitingListEntry.Entity & WaitingListEntry.PendingFlag;
+		},
+	) => {
+		const payload = {
+			waitingListEntryId: params.waitingListEntry.id,
+			clientId: params.waitingListEntry.clientId,
+		};
+		const state = Book.ReservedState.new({
+			waitingListEntryId: payload.waitingListEntryId,
+		});
+
+		return DCommon.pipe(
+			params.book,
+			Book.Entity.update({ state }),
+			Book.ReservedFlag.append(state),
+			applyFact(payload),
+		);
+	},
+);
+export type ReserveBookFact = DModeling.GetFact<typeof ReserveBookFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/book/facts/returnBook.ts

@@ -0,0 +1,32 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { type Client } from "../../client";
+import { Book } from "..";
+import * as DCommon from "@duplojs/lang/common";
+
+export const ReturnBookFact = DModeling.createFact<
+	"ReturnBook",
+	Client.Id,
+	typeof Book.Entity
+>("ReturnBook")(
+	({ applyFact }) => (
+		{
+			client,
+			book,
+		}: {
+			client: Client.Entity;
+			book: Book.Entity & Book.BorrowedFlag;
+		},
+	) => {
+		const availableState = Book.AvailableState.new({});
+
+		return DCommon.pipe(
+			book,
+			Book.Entity.update({
+				state: availableState,
+			}),
+			Book.AvailableFlag.append(availableState),
+			applyFact(client.id),
+		);
+	},
+);
+export type ReturnBookFact = DModeling.GetFact<typeof ReturnBookFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/book/facts/withdraw.ts

@@ -0,0 +1,21 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { Book } from "..";
+
+export const WithdrawBookFact = DModeling.createFact<
+	"WithdrawBook",
+	Book.WithdrawnState,
+	typeof Book.Entity
+>("WithdrawBook")(
+	({ applyFact }) => (book: Book.Entity & (Book.AvailableFlag | Book.ReservedFlag)) => {
+		const state = Book.WithdrawnState.new({});
+
+		return DCommon.pipe(
+			book,
+			Book.Entity.update({ state }),
+			Book.WithdrawnFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type WithdrawBookFact = DModeling.GetFact<typeof WithdrawBookFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/book/index.ts

@@ -0,0 +1,118 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DModeling from "@duplojs/lang/modeling";
+import { Client } from "../client";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DEither from "@duplojs/lang/either";
+import { type CreateBookFact, type BookRentalFact, type ReturnBookFact, type ReserveBookFact, type WithdrawBookFact } from "./facts";
+import { WaitingListEntry } from "../waitingListEntry";
+
+export * from "./facts";
+
+export namespace Book {
+	const namespace = DModeling.createEntityNamespace("Book");
+
+	export const Id = namespace.createNewType("Id", DDataStructure.string(), [DDataStructure.uuid()]);
+	export type Id = DDataStructure.StructureValue<typeof Id>;
+
+	export const Title = namespace.createNewType("Title", DDataStructure.string(), [
+		DDataStructure.minCharacters(1),
+		DDataStructure.maxCharacters(150),
+	]);
+	export type Title = DDataStructure.StructureValue<typeof Title>;
+
+	export const AvailableState = DModeling.createTaggedObject(
+		"AvailableState",
+		{},
+	);
+	export type AvailableState = DDataStructure.StructureValue<typeof AvailableState>;
+
+	export const BorrowedState = DModeling.createTaggedObject(
+		"BorrowedState",
+		{
+			currentBorrowerId: Client.Id,
+		},
+	);
+	export type BorrowedState = DDataStructure.StructureValue<typeof BorrowedState>;
+
+	export const ReservedState = DModeling.createTaggedObject("ReservedState", {
+		waitingListEntryId: WaitingListEntry.Id,
+	});
+	export type ReservedState = DDataStructure.StructureValue<typeof ReservedState>;
+
+	export const WithdrawnState = DModeling.createTaggedObject("WithdrawnState", {});
+	export type WithdrawnState = DDataStructure.StructureValue<typeof WithdrawnState>;
+
+	export const Entity = namespace.createEntity(() => ({
+		id: Id,
+		title: Title,
+		state: DDataStructure.union([
+			AvailableState,
+			BorrowedState,
+			ReservedState,
+			WithdrawnState,
+		]),
+	}));
+	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+
+	export type Facts = (
+		| CreateBookFact
+		| BookRentalFact
+		| ReturnBookFact
+		| ReserveBookFact
+		| WithdrawBookFact
+	);
+
+	export const AvailableFlag = DModeling.createFlag<
+		"Available",
+		AvailableState,
+		typeof Entity
+	>("Available");
+	export type AvailableFlag = DModeling.GetFlag<typeof AvailableFlag>;
+
+	export const BorrowedFlag = DModeling.createFlag<
+		"Borrowed",
+		BorrowedState,
+		typeof Entity
+	>("Borrowed");
+	export type BorrowedFlag = DModeling.GetFlag<typeof BorrowedFlag>;
+
+	export const ReservedFlag = DModeling.createFlag<
+		"Reserved",
+		ReservedState,
+		typeof Entity
+	>("Reserved");
+	export type ReservedFlag = DModeling.GetFlag<typeof ReservedFlag>;
+
+	export const WithdrawnFlag = DModeling.createFlag<
+		"Withdrawn",
+		WithdrawnState,
+		typeof Entity
+	>("Withdrawn");
+	export type WithdrawnFlag = DModeling.GetFlag<typeof WithdrawnFlag>;
+
+	export function refineState<
+		GenericEntity extends Entity,
+	>(entity: GenericEntity) {
+		return DPattern.matchWithTaggedObject(
+			entity.state,
+			{
+				AvailableState: (state) => DEither.result(
+					"AvailableState",
+					AvailableFlag.append(entity, state),
+				),
+				BorrowedState: (state) => DEither.result(
+					"BorrowedState",
+					BorrowedFlag.append(entity, state),
+				),
+				ReservedState: (state) => DEither.result(
+					"ReservedState",
+					ReservedFlag.append(entity, state),
+				),
+				WithdrawnState: (state) => DEither.result(
+					"WithdrawnState",
+					WithdrawnFlag.append(entity, state),
+				),
+			},
+		);
+	}
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/client/facts/giveBackBook.ts

@@ -0,0 +1,35 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { Client } from "..";
+import { type Book } from "../../book";
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+export const ClientGiveBackBook = DModeling.createFact<
+	"ClientGiveBackBook",
+	Book.Entity,
+	typeof Client.Entity
+>("ClientGiveBackBook")(
+	({ applyFact }) => (
+		{
+			client,
+			book,
+		}: {
+			client: Client.Entity;
+			book: Book.Entity & Book.BorrowedFlag;
+		},
+	) => {
+		const borrowedBooks = DArray.filter(
+			client.borrowedBooks,
+			(bookId) => bookId !== book.id,
+		);
+
+		return DCommon.pipe(
+			client,
+			Client.Entity.update({
+				borrowedBooks,
+			}),
+			applyFact(book),
+		);
+	},
+);
+export type ClientGiveBackBook = DModeling.GetFact<typeof ClientGiveBackBook>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/client/facts/index.ts

@@ -0,0 +1,2 @@
+export * from "./giveBackBook";
+export * from "./rentBook";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/client/facts/rentBook.ts

@@ -0,0 +1,32 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { Client } from "..";
+import { type Book } from "../../book";
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+export const ClientRentBookFact = DModeling.createFact<
+	"ClientRentBookFact",
+	Client.Entity["borrowedBooks"],
+	typeof Client.Entity
+>("ClientRentBookFact")(
+	({ applyFact }) => (
+		params: {
+			client: Client.Entity & Client.CanRentBookFlag;
+			book: Book.Entity & Book.AvailableFlag;
+		},
+	) => {
+		const borrowedBooks = DArray.push(
+			Client.CanRentBookFlag.getPayload(params.client),
+			params.book.id,
+		);
+
+		return DCommon.pipe(
+			params.client,
+			Client.Entity.update({
+				borrowedBooks,
+			}),
+			applyFact(borrowedBooks),
+		);
+	},
+);
+export type ClientRentBookFact = DModeling.GetFact<typeof ClientRentBookFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/client/index.ts

@@ -0,0 +1,59 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DArray from "@duplojs/lang/array";
+import * as DEither from "@duplojs/lang/either";
+import { type ClientRentBookFact, type ClientGiveBackBook } from "./facts";
+import { Book } from "../book";
+
+export * from "./facts";
+
+export namespace Client {
+	const namespace = DModeling.createEntityNamespace("Client");
+
+	export const Id = namespace.createNewType("Id", DDataStructure.string(), [DDataStructure.uuid()]);
+	export type Id = DDataStructure.StructureValue<typeof Id>;
+
+	export const Entity = namespace.createEntity(() => ({
+		id: Id,
+		borrowedBooks: DDataStructure.array(
+			Book.Id,
+			[DDataStructure.maxElements(5)],
+		),
+	}));
+	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+
+	export type Facts = (
+		| ClientRentBookFact
+		| ClientGiveBackBook
+	);
+
+	export const CanRentBookFlag = DModeling.createFlag<
+		"CanRentBook",
+		readonly Book.Id[] & DArray.MaxElements<4>,
+		typeof Entity
+	>("CanRentBook");
+	export type CanRentBookFlag = DModeling.GetFlag<typeof CanRentBookFlag>;
+
+	export const NoBookRentalSlotsAvailableFlag = DModeling.createFlag<
+		"NoBookRentalSlotsAvailable",
+		undefined,
+		typeof Entity
+	>("NoBookRentalSlotsAvailable");
+	export type NoBookRentalSlotsAvailableFlag = DModeling.GetFlag<typeof NoBookRentalSlotsAvailableFlag>;
+
+	export function canRentBook<
+		GenericEntity extends Entity,
+	>(client: GenericEntity) {
+		if (DArray.maxElements(client.borrowedBooks, 4)) {
+			return DEither.result(
+				"CanRentBook",
+				CanRentBookFlag.append(client, client.borrowedBooks),
+			);
+		} else {
+			return DEither.result(
+				"NoBookRentalSlotsAvailable",
+				NoBookRentalSlotsAvailableFlag.append(client, undefined),
+			);
+		}
+	}
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/index.ts

@@ -0,0 +1,3 @@
+export * from "./book";
+export * from "./client";
+export * from "./waitingListEntry";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/cancel.ts

@@ -0,0 +1,26 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+
+export const CancelWaitingListEntryFact = DModeling.createFact<
+	"CancelWaitingListEntry",
+	WaitingListEntry.CancelledState,
+	typeof WaitingListEntry.Entity
+>("CancelWaitingListEntry")(
+	({ applyFact }) => (
+		params: {
+			waitingListEntry: WaitingListEntry.Entity & (WaitingListEntry.PendingFlag | WaitingListEntry.ReadyFlag);
+			reason: WaitingListEntry.CancelledState["reason"];
+		},
+	) => {
+		const state = WaitingListEntry.CancelledState.new({ reason: params.reason });
+
+		return DCommon.pipe(
+			params.waitingListEntry,
+			WaitingListEntry.Entity.update({ state }),
+			WaitingListEntry.CancelledFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type CancelWaitingListEntryFact = DModeling.GetFact<typeof CancelWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/create.ts

@@ -0,0 +1,33 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+import { type Book } from "../../book";
+import { type Client } from "../../client";
+
+export const CreateWaitingListEntryFact = DModeling.createFact<
+	"CreateWaitingListEntry",
+	WaitingListEntry.PendingState,
+	typeof WaitingListEntry.Entity
+>("CreateWaitingListEntry")(
+	({ applyFact }) => (params: {
+		id: WaitingListEntry.Id;
+		book: Book.Entity & (Book.AvailableFlag | Book.BorrowedFlag | Book.ReservedFlag);
+		client: Client.Entity;
+		requestedAt: WaitingListEntry.RequestedAt;
+	}) => {
+		const state = WaitingListEntry.PendingState.new({});
+
+		return DCommon.pipe(
+			WaitingListEntry.Entity.new({
+				id: params.id,
+				bookId: params.book.id,
+				clientId: params.client.id,
+				requestedAt: params.requestedAt,
+				state,
+			}),
+			WaitingListEntry.PendingFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type CreateWaitingListEntryFact = DModeling.GetFact<typeof CreateWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/index.ts

@@ -0,0 +1,3 @@
+export * from "./create";
+export * from "./prepare";
+export * from "./cancel";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/prepare.ts

@@ -0,0 +1,23 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+
+export const PrepareWaitingListEntryFact = DModeling.createFact<
+	"PrepareWaitingListEntry",
+	WaitingListEntry.ReadyState,
+	typeof WaitingListEntry.Entity
+>("PrepareWaitingListEntry")(
+	({ applyFact }) => (
+		waitingListEntry: WaitingListEntry.Entity & WaitingListEntry.PendingFlag,
+	) => {
+		const state = WaitingListEntry.ReadyState.new({});
+
+		return DCommon.pipe(
+			waitingListEntry,
+			WaitingListEntry.Entity.update({ state }),
+			WaitingListEntry.ReadyFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type PrepareWaitingListEntryFact = DModeling.GetFact<typeof PrepareWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/index.ts

@@ -0,0 +1,79 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DEither from "@duplojs/lang/either";
+import { Book } from "../book";
+import { Client } from "../client";
+import { type CreateWaitingListEntryFact, type PrepareWaitingListEntryFact, type CancelWaitingListEntryFact } from "./facts";
+
+export * from "./facts";
+
+export namespace WaitingListEntry {
+	const namespace = DModeling.createEntityNamespace("WaitingListEntry");
+
+	export const Id = namespace.createNewType("Id", DDataStructure.string(), [DDataStructure.uuid()]);
+	export type Id = DDataStructure.StructureValue<typeof Id>;
+
+	export const RequestedAt = namespace.createNewType("RequestedAt", DDataStructure.date());
+	export type RequestedAt = DDataStructure.StructureValue<typeof RequestedAt>;
+
+	export const PendingState = DModeling.createTaggedObject("PendingWaitingListEntryState", {});
+	export type PendingState = DDataStructure.StructureValue<typeof PendingState>;
+
+	export const ReadyState = DModeling.createTaggedObject("ReadyWaitingListEntryState", {});
+	export type ReadyState = DDataStructure.StructureValue<typeof ReadyState>;
+
+	export const CancelledState = DModeling.createTaggedObject("CancelledWaitingListEntryState", {
+		reason: DDataStructure.literal(["book-withdrawn", "client-cancelled"]),
+	});
+	export type CancelledState = DDataStructure.StructureValue<typeof CancelledState>;
+
+	export const Entity = namespace.createEntity(() => ({
+		id: Id,
+		bookId: Book.Id,
+		clientId: Client.Id,
+		requestedAt: RequestedAt,
+		state: DDataStructure.union([PendingState, ReadyState, CancelledState]),
+	}));
+	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+
+	export type Facts = CreateWaitingListEntryFact | PrepareWaitingListEntryFact | CancelWaitingListEntryFact;
+
+	export const PendingFlag = DModeling.createFlag<
+		"PendingWaitingListEntry",
+		PendingState,
+		typeof Entity
+	>("PendingWaitingListEntry");
+	export type PendingFlag = DModeling.GetFlag<typeof PendingFlag>;
+
+	export const ReadyFlag = DModeling.createFlag<
+		"ReadyWaitingListEntry",
+		ReadyState,
+		typeof Entity
+	>("ReadyWaitingListEntry");
+	export type ReadyFlag = DModeling.GetFlag<typeof ReadyFlag>;
+
+	export const CancelledFlag = DModeling.createFlag<
+		"CancelledWaitingListEntry",
+		CancelledState,
+		typeof Entity
+	>("CancelledWaitingListEntry");
+	export type CancelledFlag = DModeling.GetFlag<typeof CancelledFlag>;
+
+	export function refineState<GenericEntity extends Entity>(waitingListEntry: GenericEntity) {
+		return DPattern.matchWithTaggedObject(waitingListEntry.state, {
+			PendingWaitingListEntryState: (state) => DEither.result(
+				"PendingWaitingListEntry",
+				PendingFlag.append(waitingListEntry, state),
+			),
+			ReadyWaitingListEntryState: (state) => DEither.result(
+				"ReadyWaitingListEntry",
+				ReadyFlag.append(waitingListEntry, state),
+			),
+			CancelledWaitingListEntryState: (state) => DEither.result(
+				"CancelledWaitingListEntry",
+				CancelledFlag.append(waitingListEntry, state),
+			),
+		});
+	}
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/index.ts

@@ -0,0 +1,4 @@
+export * from "./aggregates";
+export * from "./entities";
+export * from "./refinements";
+export type * from "./repositories";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/refinements/index.ts

@@ -0,0 +1 @@
+export * from "./refineLinkBetweenClientAndBorrowedBook";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/refinements/refineLinkBetweenClientAndBorrowedBook.ts

@@ -0,0 +1,34 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import { Book, type Client } from "../entities";
+import * as DInvocation from "@duplojs/lang/invocation";
+
+export function refineLinkBetweenClientAndBorrowedBook(
+	client: Client.Entity,
+	book: Book.Entity & Book.BorrowedFlag,
+) {
+	if (
+		DArray.includes(client.borrowedBooks, book.id)
+		&& client.id === Book.BorrowedFlag.getPayload(book).currentBorrowerId
+	) {
+		return DCommon.pipe(
+			{
+				client,
+				book,
+			},
+			DInvocation.evidenceResult(
+				"client-with-borrowed-book",
+			),
+		);
+	}
+
+	return DCommon.pipe(
+		{
+			client,
+			book,
+		},
+		DInvocation.evidenceResult(
+			"client-and-book-without-link",
+		),
+	);
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/book.ts

@@ -0,0 +1,16 @@
+import type * as DInvocation from "@duplojs/lang/invocation";
+import { type Book } from "../entities";
+import type * as DEither from "@duplojs/lang/either";
+
+export interface BookRepository {
+	generateId(): Book.Id & DInvocation.Evidence<"generated">;
+	titleIsAlreadyRegistered(title: Book.Title): Promise<
+		| DInvocation.EvidenceResult<"title-already-registered", Book.Title>
+		| DInvocation.EvidenceResult<"title-not-registered", Book.Title>
+	>;
+	rankAvailability: DInvocation.SignedFunction<
+		"rankAvailability",
+		(book: Book.Entity) => Promise<void>
+	>;
+	findById(id: Book.Id): Promise<DEither.Maybe<Book.Entity>>;
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/client.ts

@@ -0,0 +1,7 @@
+import type * as DEither from "@duplojs/lang/either";
+import { type Client } from "../entities";
+
+export interface ClientRepository {
+	findById(id: Client.Id): Promise<DEither.Maybe<Client.Entity>>;
+
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/email.ts

@@ -0,0 +1,12 @@
+import type * as DInvocation from "@duplojs/lang/invocation";
+import { type Client, type Book } from "../entities";
+
+export interface EmailRepository {
+	sendRentInformationalEmail: DInvocation.SignedFunction<
+		"sendRentInformationalEmail",
+		(params: {
+			client: Client.Entity;
+			book: Book.Entity;
+		}) => Promise<void>
+	>;
+}