shori-sdk-ts 1.0.1

package/src/modules/caso/caseCommentModule.ts

@@ -0,0 +1,88 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import { CommentFilter } from "./filter/commentFilter.js";
+import { AddCommentRequest } from "./dto/request/addCommentRequest.js";
+import { AddCommentResponse } from "./dto/response/addCommentResponse.js";
+import { CommentSearchResult } from "./dto/response/commentSearchResult.js";
+import { CommentResponse } from "./dto/response/commentResponse.js";
+
+export { CommentFilter };
+
+/**
+ * Sub-módulo para gestión de comentarios de casos.
+ *
+ * Se accede a través de `client.caso().comment()`.
+ *
+ * @example
+ * ```ts
+ * // Agregar comentario
+ * await client.caso().comment().add({
+ *   casoId: "caso-uuid",
+ *   comment: "El cliente confirmó su disponibilidad.",
+ * });
+ *
+ * // Buscar comentarios (una página)
+ * const result = await client.caso().comment().search(
+ *   new CommentFilter().casoId("caso-uuid").pageSize(20)
+ * );
+ *
+ * // Obtener todos los comentarios
+ * const todos = await client.caso().comment().searchAll(
+ *   new CommentFilter().casoId("caso-uuid")
+ * );
+ * ```
+ */
+export class CaseCommentModule {
+  private readonly config: ShoriConfig;
+  private readonly http: HttpExecutor;
+
+  constructor(config: ShoriConfig, http: HttpExecutor) {
+    this.config = config;
+    this.http = http;
+  }
+
+  /**
+   * Agrega un comentario a un caso existente.
+   *
+   * @param request - UUID del caso y texto del comentario
+   * @returns Respuesta con el ID del comentario creado
+   */
+  async add(request: AddCommentRequest): Promise<AddCommentResponse> {
+    const url = `${this.config.caseUrl}/v3/comments`;
+    return this.http.post<AddCommentResponse>(url, request);
+  }
+
+  /**
+   * Busca comentarios de un caso (una página).
+   *
+   * @param filter - Filtros y paginación
+   * @returns Página de comentarios con el total
+   */
+  async search(filter: CommentFilter): Promise<CommentSearchResult> {
+    filter.applyDefaultInOperators();
+    const url = `${this.config.caseUrl}/v3/comments/search`;
+    return this.http.post<CommentSearchResult>(url, filter);
+  }
+
+  /**
+   * Busca TODOS los comentarios de un caso, paginando automáticamente
+   *
+   * @param filter - Filtros de búsqueda
+   * @returns Lista completa de comentarios
+   */
+  async searchAll(filter: CommentFilter): Promise<CommentResponse[]> {
+    filter.applyDefaultInOperators();
+    const url = `${this.config.caseUrl}/v3/comments/search`;
+
+    const result = await this.http.post<CommentSearchResult>(url, filter);
+    const all: CommentResponse[] = [...(result?.comments ?? [])];
+
+    const count = result?.count ?? 0;
+    const totalPages = Math.ceil(count / filter.getPageSize());
+    if (filter.getPageNumber() < totalPages - 1) {
+      const rest = await this.searchAll(filter.copyForNextPage());
+      all.push(...rest);
+    }
+    return all;
+  }
+}

package/src/modules/caso/caseFileTypologyModule.ts

@@ -0,0 +1,140 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import { TypologyResponse } from "./dto/response/typologyResponse.js";
+
+/**
+ * Sub-módulo para gestión de tipologías de archivos en Shori.
+ *
+ * Permite consultar y gestionar las tipologías de archivos asociadas a los
+ * productos (casoType), incluyendo sus categorías.
+ * Se accede a través de `client.caso().fileTypology()`.
+ *
+ * @example
+ * ```ts
+ * // Obtener tipologías de un producto
+ * const tipologias = await client.caso().fileTypology().getByCasoType({
+ *   casoTypeId: "producto-uuid",
+ * });
+ * tipologias.forEach(t => console.log(t.name));
+ *
+ * // Obtener categorías de una tipología
+ * const tipologia = await client.caso().fileTypology().getCategoriesByTypology({
+ *   fileTypologyId: "tipologia-uuid",
+ * });
+ * tipologia.categories?.forEach(c => console.log(c.name));
+ *
+ * // Obtener categoría por ID
+ * const cat = await client.caso().fileTypology().getCategoryById({
+ *   categoryId: "categoria-uuid",
+ * });
+ *
+ * // Crear nueva categoría
+ * const nueva = await client.caso().fileTypology().addCategory({
+ *   fileTypologyId: "tipologia-uuid",
+ *   name: "Contratos",
+ * });
+ * ```
+ */
+export class CaseFileTypologyModule {
+  private readonly config: ShoriConfig;
+  private readonly http: HttpExecutor;
+
+  constructor(config: ShoriConfig, http: HttpExecutor) {
+    this.config = config;
+    this.http = http;
+  }
+
+  /**
+   * Obtiene todas las tipologías de archivos asociadas a un producto (casoType).
+   *
+   * @example
+   * ```ts
+   * const tipologias = await client.caso().fileTypology().getByCasoType({
+   *   casoTypeId: "producto-uuid",
+   * });
+   * console.log(`Tipologías disponibles: ${tipologias.length}`);
+   * tipologias.forEach(t => console.log(` - ${t.name}`));
+   * ```
+   *
+   * @param request - UUID del producto (casoType)
+   * @returns Lista de tipologías del producto, o lista vacía si no tiene
+   */
+  async getByCasoType(request: {
+    casoTypeId: string;
+  }): Promise<TypologyResponse[]> {
+    const params = new URLSearchParams({ casoTypeId: request.casoTypeId });
+    const url = `${this.config.caseUrl}/v3/fileTypology/getByCasoType?${params.toString()}`;
+    return this.http.getList<TypologyResponse>(url);
+  }
+
+  /**
+   * Obtiene una tipología con todas sus categorías asociadas.
+   *
+   * @example
+   * ```ts
+   * const tipologia = await client.caso().fileTypology().getCategoriesByTypology({
+   *   fileTypologyId: "tipologia-uuid",
+   * });
+   * console.log("Tipología:", tipologia.name);
+   * console.log("Categorías:", tipologia.categories?.length);
+   * ```
+   *
+   * @param request - UUID de la tipología a consultar
+   * @returns Tipología con sus categorías
+   */
+  async getCategoriesByTypology(request: {
+    fileTypologyId: string;
+  }): Promise<TypologyResponse> {
+    const params = new URLSearchParams({
+      fileTypologyId: request.fileTypologyId,
+    });
+    const url = `${this.config.caseUrl}/v3/fileTypology/getCategoriesByTypology?${params.toString()}`;
+    return this.http.get<TypologyResponse>(url);
+  }
+
+  /**
+   * Obtiene los datos de una categoría por su UUID.
+   *
+   * @example
+   * ```ts
+   * const categoria = await client.caso().fileTypology().getCategoryById({
+   *   categoryId: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+   * });
+   * console.log("Categoría:", categoria.name);
+   * ```
+   *
+   * @param request - UUID de la categoría
+   * @returns Datos de la categoría
+   */
+  async getCategoryById(request: {
+    categoryId: string;
+  }): Promise<TypologyResponse> {
+    const params = new URLSearchParams({ categoryId: request.categoryId });
+    const url = `${this.config.caseUrl}/v3/fileTypology/getCategoryById?${params.toString()}`;
+    return this.http.get<TypologyResponse>(url);
+  }
+
+  /**
+   * Crea una nueva categoría dentro de una tipología de archivos.
+   *
+   * @example
+   * ```ts
+   * const nueva = await client.caso().fileTypology().addCategory({
+   *   fileTypologyId: "tipologia-uuid",
+   *   name: "Contratos",
+   * });
+   * console.log("Categoría creada:", nueva.id);
+   * ```
+   *
+   * @param request - ID de la tipología y nombre de la nueva categoría
+   * @returns Datos de la categoría creada
+   */
+  async addCategory(request: {
+    fileTypologyId: string;
+    name: string;
+    [key: string]: unknown;
+  }): Promise<TypologyResponse> {
+    const url = `${this.config.caseUrl}/v3/fileTypology/addCategory`;
+    return this.http.post<TypologyResponse>(url, request);
+  }
+}

package/src/modules/caso/caseFilesModule.ts

@@ -0,0 +1,168 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import type { RepoModule } from "../repo/repoModule.js";
+import { GetAttachmentFilesRequest } from "./dto/request/getAttachmentFilesRequest.js";
+import { CasoFileSearchResponse } from "./dto/response/casoFileSearchResponse.js";
+import { CaseFileSearchResult } from "./dto/response/caseFileSearchResult.js";
+import { CasoFileUpdateRequest } from "./dto/request/casoFileUpdateRequest.js";
+
+/**
+ * Sub-módulo para gestión de archivos adjuntos de casos en Shori.
+ *
+ * Permite buscar, descargar, actualizar y eliminar documentos asociados a un caso.
+ * Se accede a través de `client.caso().files()`.
+ *
+ * @example
+ * ```ts
+ * // Buscar metadatos de archivos (sin descargar)
+ * const archivos = await client.caso().files().search("caso-uuid");
+ * archivos.forEach(a => console.log(`${a.fileName}.${a.extension} → ${a.documentId}`));
+ *
+ * // Descargar archivos adjuntos como File
+ * const docs = await client.caso().files().getAttachments({ casoId: "caso-uuid" });
+ * docs.forEach(d => console.log(d.file?.name, d.file?.size));
+ *
+ * // Actualizar metadatos de un archivo
+ * await client.caso().files().update({ id: "archivo-uuid", isValid: true });
+ *
+ * // Eliminar un documento
+ * await client.caso().files().delete("documento-uuid");
+ * ```
+ */
+export class CaseFilesModule {
+  private readonly config: ShoriConfig;
+  private readonly http: HttpExecutor;
+  private readonly repoModule: RepoModule;
+
+  constructor(config: ShoriConfig, http: HttpExecutor, repoModule: RepoModule) {
+    this.config = config;
+    this.http = http;
+    this.repoModule = repoModule;
+  }
+
+  /**
+   * Busca los metadatos de archivos adjuntos de un caso (sin descargarlos).
+   *
+   * Para descargar el contenido de los archivos, usa `getAttachments()`.
+   *
+   * @example
+   * ```ts
+   * const archivos = await client.caso().files().search(GetAttachmentFilesRequest
+   * .builder()
+   *  .casoId("caso-uuid")
+   * .build());
+   * for (const archivo of archivos) {
+   *   console.log(`${archivo.fileName}.${archivo.extension}`);
+   *   console.log("Documento ID:", archivo.documentId);
+   * }
+   * ```
+   *
+   * @param request {@link GetAttachmentFilesRequest} - Cuerpo de la solicitud
+   * @returns Lista de metadatos de archivos adjuntos
+   */
+  async search(
+    request: GetAttachmentFilesRequest,
+  ): Promise<CasoFileSearchResponse[]> {
+    const url = `${this.config.caseUrl}/v3/caso/files/search`;
+    const result = await this.http.post<CaseFileSearchResult>(url, request);
+    return result?.files ?? [];
+  }
+
+  /**
+   * Descarga los archivos adjuntos de un caso como objetos `File`.
+   *
+   * Realiza la búsqueda de metadatos y luego descarga cada archivo del repositorio.
+   * Pagina automáticamente si hay más de una página de resultados.
+   *
+   * @example
+   * ```ts
+   * const docs = await client.caso().files().getAttachments({ casoId: "caso-uuid" });
+   *
+   * // Browser — trigger download de cada archivo
+   * for (const doc of docs) {
+   *   const url = URL.createObjectURL(doc.file!);
+   *   const a = document.createElement("a");
+   *   a.href = url;
+   *   a.download = doc.file!.name;
+   *   a.click();
+   * }
+   *
+   * // Node.js — guardar en disco
+   * for (const doc of docs) {
+   *   const buffer = Buffer.from(await doc.file!.arrayBuffer());
+   *   await fs.promises.writeFile(`/descargas/${doc.file!.name}`, buffer);
+   * }
+   * ```
+   *
+   * @param request - UUID del caso
+   * @returns Lista de archivos adjuntos con el `File` descargado en cada uno
+   */
+  async getAttachments(
+    request: GetAttachmentFilesRequest,
+  ): Promise<CasoFileSearchResponse[]> {
+    const url = `${this.config.caseUrl}/v3/caso/files/search`;
+
+    const result = await this.http.post<CaseFileSearchResult>(url, request);
+    if (!result?.files?.length) return [];
+
+    const files: CasoFileSearchResponse[] = [];
+
+    await Promise.all(
+      result.files.map(async (fileInfo) => {
+        if (!fileInfo.documentId) return;
+        const fileName = `${fileInfo.fileName ?? "archivo"}.${fileInfo.extension ?? "bin"}`;
+        const downloaded = await this.repoModule
+          .download()
+          .byDocument({ documentId: fileInfo.documentId, fileName });
+        files.push({ file: downloaded, ...fileInfo });
+      }),
+    );
+
+    // Paginar si hay más resultados
+    const count = result.count ?? 0;
+    const totalPages = Math.ceil(count / request.pagination.pageSize);
+    if (request.pagination.pageNumber < totalPages - 1) {
+      const more = await this.getAttachments(request);
+      files.push(...more);
+    }
+
+    return files;
+  }
+
+  /**
+   * Actualiza los metadatos de un archivo adjunto.
+   *
+   * @example
+   * ```ts
+   * await client.caso().files().update({
+   *   id: "archivo-uuid",
+   *   isValid: true,
+   *   isDeleted: false,
+   * });
+   * ```
+   *
+   * @param request - ID del archivo y campos a actualizar
+   */
+  async update(request: CasoFileUpdateRequest): Promise<void> {
+    if (!request.isValid) request.isValid = false;
+    const url = `${this.config.caseUrl}/v3/caso/files`;
+    await this.http.put<unknown>(url, request);
+  }
+
+  /**
+   * Elimina un documento adjunto de un caso.
+   *
+   * @example
+   * ```ts
+   * await client.caso().files().delete("documento-uuid");
+   * ```
+   *
+   * @param documentId - UUID del documento a eliminar
+   * @returns `true` si el documento fue eliminado exitosamente
+   */
+  async delete(documentId: string): Promise<boolean> {
+    const url = `${this.config.caseUrl}/v3/caso/delete_file?documentId=${documentId}`;
+    await this.http.post<unknown>(url);
+    return true;
+  }
+}

package/src/modules/caso/caseModule.ts

@@ -0,0 +1,182 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import type { RepoModule } from "../repo/repoModule.js";
+import type { CasoCreateRequest } from "./dto/request/casoCreateRequest.js";
+import type { CasoUpdateRequest } from "./dto/request/casoUpdateRequest.js";
+import type { CasoResponse } from "./dto/response/casoResponse.js";
+import type {
+  CasoCreateResponse,
+  CasoCreateResponseAux,
+} from "./dto/response/casoCreateResponse.js";
+import type { CasoSearchResponse } from "./dto/response/casoSearchResponse.js";
+import type { CaseSearchResult } from "./dto/response/caseSearchResult.js";
+import { GetAttachmentFilesRequest } from "./dto/request/getAttachmentFilesRequest.js";
+import { CaseStateModule } from "./caseStateModule.js";
+import { CaseCommentModule } from "./caseCommentModule.js";
+import { CaseTypeModule } from "./caseTypeModule.js";
+import { CaseFilesModule } from "./caseFilesModule.js";
+import { CaseFileTypologyModule } from "./caseFileTypologyModule.js";
+import { CaseFilter } from "./filter/caseFilter.js";
+
+/**
+ * Módulo principal para gestión de casos en la plataforma Shori.
+ *
+ * Se accede a través de `client.caso()`.
+ *
+ * @example
+ * ```ts
+ * // Buscar — build() valida y retorna CaseFilter listo para enviar
+ * const result = await client.caso().search(
+ *   new CaseFilter()
+ *     .casoTypeId(FilterOperator.EQ, "tipo-uuid")
+ *     .workingSubStateId(FilterOperator.IN, ...openStateIds)
+ *     .pageSize(20)
+ *     .build()
+ * );
+ *
+ * // Auto-paginación
+ * const todos = await client.caso().searchAll(
+ *   new CaseFilter()
+ *     .casoTypeId(FilterOperator.EQ, "tipo-uuid")
+ *     .workingSubStateId(FilterOperator.IN, ...openStateIds)
+ *     .build()
+ * );
+ * ```
+ */
+export class CaseModule {
+  private readonly config: ShoriConfig;
+  private readonly http: HttpExecutor;
+  private readonly stateModule: CaseStateModule;
+  private readonly commentModule: CaseCommentModule;
+  private readonly casoTypeModule: CaseTypeModule;
+  private readonly filesModule: CaseFilesModule;
+  private readonly fileTypologyModule: CaseFileTypologyModule;
+
+  constructor(config: ShoriConfig, http: HttpExecutor, repoModule: RepoModule) {
+    this.config = config;
+    this.http = http;
+    this.stateModule = new CaseStateModule(config, http);
+    this.commentModule = new CaseCommentModule(config, http);
+    this.casoTypeModule = new CaseTypeModule(config, http);
+    this.filesModule = new CaseFilesModule(config, http, repoModule);
+    this.fileTypologyModule = new CaseFileTypologyModule(config, http);
+  }
+
+  // ── Sub-módulos ────────────────────────────────────────────────────────────
+
+  state(): CaseStateModule {
+    return this.stateModule;
+  }
+  comment(): CaseCommentModule {
+    return this.commentModule;
+  }
+  casoType(): CaseTypeModule {
+    return this.casoTypeModule;
+  }
+  files(): CaseFilesModule {
+    return this.filesModule;
+  }
+  fileTypology(): CaseFileTypologyModule {
+    return this.fileTypologyModule;
+  }
+
+  // ── CRUD básico ────────────────────────────────────────────────────────────
+
+  async findById(uuid: string): Promise<CasoResponse> {
+    const url = `${this.config.caseUrl}/v3/caso?casoId=${uuid}`;
+    return this.http.get<CasoResponse>(url);
+  }
+
+  async create(request: CasoCreateRequest): Promise<CasoCreateResponse> {
+    const url = `${this.config.caseUrl}/v3/caso`;
+    const { caso, casoId }: CasoCreateResponseAux =
+      await this.http.post<CasoCreateResponseAux>(url, request);
+    return { casoId: caso, casoNumber: casoId };
+  }
+
+  async update(request: CasoUpdateRequest): Promise<void> {
+    const url = `${this.config.caseUrl}/v3/caso`;
+    await this.http.put<unknown>(url, request);
+  }
+
+  // ── Búsqueda ───────────────────────────────────────────────────────────────
+
+  /**
+   * Busca casos (una página). Acepta el resultado de `CaseFilter.build()`
+   *
+   * @example
+   * ```ts
+   * const result = await client.caso().search(
+   *   new CaseFilter()
+   *     .casoTypeId(FilterOperator.EQ, "tipo-uuid")
+   *     .workingSubStateId(FilterOperator.IN, "estado-1", "estado-2")
+   *     .pageSize(20)
+   *     .build()
+   * );
+   * ```
+   */
+  async search(filter: CaseFilter): Promise<CaseSearchResult> {
+    const url = `${this.config.caseUrl}/v3/caso/search`;
+    return this.http.post<CaseSearchResult>(url, filter);
+  }
+
+  /**
+   * Busca TODOS los casos paginando automáticamente.
+   *
+   * @example
+   * ```ts
+   * const todos = await client.caso().searchAll(
+   *   new CaseFilter()
+   *     .casoTypeId(FilterOperator.EQ, "tipo-uuid")
+   *     .workingSubStateId(FilterOperator.IN, ...openStateIds)
+   *     .pageSize(100)
+   *     .build()
+   * );
+   * ```
+   */
+  async searchAll(filter: CaseFilter): Promise<CasoSearchResponse[]> {
+    const url = `${this.config.caseUrl}/v3/caso/search`;
+    const result = await this.http.post<CaseSearchResult>(url, filter);
+    const all: CasoSearchResponse[] = [...(result?.casoResponse ?? [])];
+
+    const count = result?.count ?? 0;
+    const totalPages = Math.ceil(count / filter.getPageSize());
+    if (filter.getPageNumber() < totalPages - 1) {
+      const rest = await this.searchAll(filter.copyForNextPage());
+      all.push(...rest);
+    }
+    return all;
+  }
+
+  /** Busca casos e incluye archivos adjuntos (una página). */
+  async searchWithAttachments(filter: CaseFilter): Promise<CaseSearchResult> {
+    const result = await this.search(filter);
+    await Promise.all(
+      (result?.casoResponse ?? []).map(async (caso: CasoSearchResponse) => {
+        if (caso.caso) {
+          caso.files = await this.filesModule.getAttachments(
+            GetAttachmentFilesRequest.builder().casoId(caso.caso).build(),
+          );
+        }
+      }),
+    );
+    return result;
+  }
+
+  /** Busca TODOS los casos con archivos adjuntos. */
+  async searchAllWithAttachments(
+    filter: CaseFilter,
+  ): Promise<CasoSearchResponse[]> {
+    const cases = await this.searchAll(filter);
+    await Promise.all(
+      cases.map(async (caso: CasoSearchResponse) => {
+        if (caso.caso) {
+          caso.files = await this.filesModule.getAttachments(
+            GetAttachmentFilesRequest.builder().casoId(caso.caso).build(),
+          );
+        }
+      }),
+    );
+    return cases;
+  }
+}

package/src/modules/caso/caseStateModule.ts

@@ -0,0 +1,51 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import { NextStateRequest } from "./dto/request/nextStateRequest.js";
+
+/**
+ * Sub-módulo para gestión del flujo de estados de un caso.
+ *
+ * Se accede a través de `client.caso().state()`.
+ *
+ * @example
+ * ```ts
+ * // Avanzar al siguiente estado
+ * await client.caso().state().next({
+ *   casoId: "caso-uuid",
+ *   stateId: "siguiente-estado-uuid",
+ * });
+ *
+ * // Obtener estados disponibles del tipo de caso
+ * const product = await client.caso().casoType().findById("tipo-uuid");
+ * const openStates = product.states?.filter(s => s.isOpen) ?? [];
+ * ```
+ */
+export class CaseStateModule {
+  private readonly config: ShoriConfig;
+  private readonly http: HttpExecutor;
+
+  constructor(config: ShoriConfig, http: HttpExecutor) {
+    this.config = config;
+    this.http = http;
+  }
+
+  /**
+   * Avanza el caso al siguiente estado en el flujo de trabajo.
+   *
+   * @example
+   * ```ts
+   * await client.caso().state().next({
+   *   casoId: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+   *   stateId: "estado-destino-uuid",
+   * });
+   * ```
+   *
+   * @param request - UUID del caso y UUID del estado destino
+   * @returns `true` si el cambio fue exitoso
+   */
+  async next(request: NextStateRequest): Promise<boolean> {
+    const url = `${this.config.caseUrl}/v3/caso/setNextState`;
+    await this.http.post<unknown>(url, request);
+    return true;
+  }
+}

package/src/modules/caso/caseTypeModule.ts

@@ -0,0 +1,69 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import { ProductResponse } from "./dto/response/productResponse.js";
+
+/**
+ * Sub-módulo para consultar Productos (tipos de caso) en Shori.
+ *
+ * En la jerarquía de Shori: Servicio → Proceso → **Producto (casoType)** → Caso.
+ *
+ * Se accede a través de `client.caso().casoType()`.
+ *
+ * @example
+ * ```ts
+ * // Obtener la definición del producto con sus estados
+ * const product = await client.caso().casoType().findById("tipo-uuid");
+ *
+ * // Obtener IDs de estados "abiertos" para filtrar búsquedas
+ * const openStateIds = product.states
+ *   ?.filter(s => s.isOpen)
+ *   .map(s => s.id) ?? [];
+ *
+ * const casos = await client.caso().searchAll(
+ *   new CaseFilter()
+ *     .casoTypeId(FilterOperator.EQ, "tipo-uuid")
+ *     .workingSubStateId(FilterOperator.IN, ...openStateIds)
+ * );
+ * ```
+ */
+export class CaseTypeModule {
+  private readonly config: ShoriConfig;
+  private readonly http: HttpExecutor;
+
+  constructor(config: ShoriConfig, http: HttpExecutor) {
+    this.config = config;
+    this.http = http;
+  }
+
+  /**
+   * Obtiene la definición completa de un Producto (tipo de caso) por su UUID.
+   *
+   * Incluye los estados disponibles del flujo, formularios y configuración.
+   *
+   * @example
+   * ```ts
+   * const product = await client.caso().casoType().findById("tipo-uuid");
+   * console.log(product.name);           // nombre del producto
+   * console.log(product.states?.length); // cantidad de estados
+   * ```
+   *
+   * @param uuid - UUID del tipo de caso (producto)
+   * @returns Definición completa del producto
+   */
+  async findById(uuid: string): Promise<ProductResponse> {
+    const url = `${this.config.caseUrl}/v3/casoType/${uuid}`;
+    return this.http.get<ProductResponse>(url);
+  }
+
+  /**
+   * Obtiene la definición básica (sin estados detallados) de un Producto.
+   *
+   * Más rápido que `findById` cuando no necesitas los estados.
+   *
+   * @param uuid - UUID del tipo de caso
+   */
+  async findByIdLite(uuid: string): Promise<ProductResponse> {
+    const url = `${this.config.caseUrl}/v3/casoType/${uuid}/lite`;
+    return this.http.get<ProductResponse>(url);
+  }
+}