@longzai-intelligence/pagination 0.0.1 → 0.0.3

package/README.md

@@ -10,209 +10,42 @@ bun add @longzai-intelligence/pagination
 
 ## 特性
 
-- 类型安全的分页参数定义
-- 支持 page/pageSize 和 limit/offset 两种分页风格
-- 支持游标分页
-- 提供参数验证工具
-- 提供 TypeORM 适配器（可选）
-
-## 快速开始
-
-### 基本使用
-
-```typescript
-import {
-  normalizePagination,
-  calculateOffset,
-  createPaginatedResult,
-  type PaginationParams,
-  type PaginatedResult,
-} from '@longzai-intelligence/pagination';
-
-// 规范化分页参数
-const params: PaginationParams = { page: 2, pageSize: 20 };
-const { page, pageSize } = normalizePagination(params);
-
-// 计算偏移量
-const offset = calculateOffset(page, pageSize);
-
-// 创建分页结果
-const result: PaginatedResult<User> = createPaginatedResult(
-  users,
-  total,
-  page,
-  pageSize,
-);
-```
-
-### 参数验证
-
-```typescript
-import {
-  isValidPage,
-  isValidPageSize,
-  isValidPagination,
-} from '@longzai-intelligence/pagination';
-
-if (isValidPagination(params)) {
-  // 参数有效
-}
-
-if (isValidPage(1) && isValidPageSize(20)) {
-  // 页码和页面大小有效
-}
-```
-
-### TypeORM 适配器
-
-```typescript
-import {
-  paginateWithRepository,
-  paginateWithQueryBuilder,
-} from '@longzai-intelligence/pagination';
-
-// 使用 Repository 分页
-const result = await paginateWithRepository(userRepository, {
-  page: 1,
-  pageSize: 20,
-}, {
-  where: { active: true },
-  order: { createdAt: 'DESC' },
-});
-
-// 使用 QueryBuilder 分页
-const qb = userRepository.createQueryBuilder('user');
-const result = await paginateWithQueryBuilder(qb, { page: 1, pageSize: 20 });
-```
-
-## API 文档
-
-### 类型
-
-#### PaginationParams
-
-```typescript
-interface PaginationParams {
-  page?: number;      // 页码，从 1 开始
-  pageSize?: number;  // 每页数量
-}
-```
-
-#### OffsetPaginationParams
-
-```typescript
-interface OffsetPaginationParams {
-  limit?: number;   // 每页数量
-  offset?: number;  // 偏移量
-}
-```
-
-#### PaginatedResult
-
-```typescript
-interface PaginatedResult<T> {
-  items: T[];           // 数据项
-  total: number;        // 总记录数
-  page: number;         // 当前页码
-  pageSize: number;     // 每页数量
-  totalPages: number;   // 总页数
-  hasNextPage: boolean;    // 是否有下一页
-  hasPreviousPage: boolean; // 是否有上一页
-}
-```
-
-#### SortParams
-
-```typescript
-interface SortParams<T extends string = string> {
-  sortBy?: T;                 // 排序字段
-  sortOrder?: 'asc' | 'desc'; // 排序方向
-}
-```
-
-### 常量
-
-#### PAGINATION_DEFAULTS
-
-```typescript
-const PAGINATION_DEFAULTS = {
-  page: 1,
-  pageSize: 20,
-  maxPageSize: 100,
-  minPageSize: 1,
-} as const;
-```
-
-### 工具函数
-
-#### normalizePagination(params?)
-
-规范化分页参数，确保参数在有效范围内。
-
-```typescript
-const { page, pageSize } = normalizePagination({ page: 2, pageSize: 50 });
-```
-
-#### calculateOffset(page, pageSize)
-
-计算偏移量。
-
-```typescript
-const offset = calculateOffset(2, 20); // 20
-```
-
-#### calculateTotalPages(total, pageSize)
-
-计算总页数。
-
-```typescript
-const totalPages = calculateTotalPages(100, 20); // 5
-```
-
-#### hasNextPage(page, totalPages) / hasPreviousPage(page)
-
-判断是否有下一页/上一页。
-
-```typescript
-hasNextPage(1, 5);     // true
-hasPreviousPage(1);    // false
-```
-
-#### offsetToPage(offset, limit) / pageToOffset(page, pageSize)
-
-分页风格转换。
-
-```typescript
-offsetToPage(20, 20);  // { page: 2, pageSize: 20 }
-pageToOffset(2, 20);   // { offset: 20, limit: 20 }
-```
-
-### 验证函数
-
-#### isValidPage(page)
-
-验证页码是否有效（正整数）。
-
-#### isValidPageSize(pageSize)
-
-验证每页数量是否有效（1-100 之间的整数）。
-
-#### isValidOffset(offset)
-
-验证偏移量是否有效（非负整数）。
-
-#### isValidLimit(limit)
-
-验证限制数量是否有效（1-100 之间的整数）。
-
-#### isValidPagination(params)
-
-验证分页参数对象是否有效。
-
-#### isValidOffsetPagination(params)
-
-验证 offset 分页参数对象是否有效。
+- 类型安全的分页参数定义（page/pageSize、limit/offset、cursor）
+- Schema 工厂函数动态创建分页 Schema
+- 预设函数提供场景化分页方案
+- 参数验证工具
+- TypeORM 适配器（可选）
+- Hono 适配器（可选）
+
+## 导出概览
+
+### 主入口 `@longzai-intelligence/pagination`
+
+| 分类 | 导出 |
+|------|------|
+| 参数类型 | `PaginationParams`、`OffsetPaginationParams`、`CursorPaginationParams` |
+| 结果类型 | `PaginatedResult`、`OffsetPaginatedResult`、`CursorPaginatedResult`、`CompactPaginatedResult` |
+| 排序类型 | `SortOrder`、`SortParams`、`MultiSortParams` |
+| Schema 工厂 | `createPaginationSchema`、`createResultSchema` |
+| 预设函数 | `createTablePreset`、`createInfiniteScrollPreset`、`createTimelinePreset`、`createCompactListPreset` |
+| 工具函数 | `normalizePagination`、`calculateOffset`、`createPaginatedResult`、`createPaginationDefaults` |
+| 验证函数 | `isValidPage`、`isValidPageSize`、`isValidPagination` 等 |
+
+### 子路径导出
+
+| 路径 | 说明 |
+|------|------|
+| `@longzai-intelligence/pagination/typeorm` | TypeORM 适配器 |
+| `@longzai-intelligence/pagination/hono` | Hono 适配器 |
+
+## 依赖要求
+
+| 包 | 版本 | 说明 |
+|------|------|------|
+| typeorm | `^0.3.0` | 可选，使用 TypeORM 适配器时需要 |
+| zod | `^4.0.0` | 可选，使用 Schema 功能时需要 |
+| hono | `^4.0.0` | 可选，使用 Hono 适配器时需要 |
 
 ## 许可证
 
-MIT
+UNLICENSED

package/dist/hono.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});let e=require(`zod`);function t(e){if(e===void 0)return;let t=Number(e);return Number.isNaN(t)?void 0:t}function n(n,r){let i=r.shape,a={};for(let[r]of Object.entries(i))if(n[r]!==void 0){let o=i[r];o instanceof e.z.ZodNumber||o instanceof e.z.ZodOptional&&o.unwrap()instanceof e.z.ZodNumber?a[r]=t(n[r]):a[r]=n[r]}return r.parse(a)}function r(e,t){let n=e.sortBy,r=e.sortOrder;if(n&&t&&!t.includes(n))return{};if(r&&r!==`asc`&&r!==`desc`)return{sortBy:n};let i={};return n&&(i.sortBy=n),r&&(i.sortOrder=r),i}exports.parsePaginationFromQuery=n,exports.parseSortFromQuery=r;

package/dist/hono.d.cts

@@ -0,0 +1,15 @@
+import { s as SortParams } from "./index-DpbbjAwO.cjs";
+import * as _$zod from "zod";
+import { z } from "zod";
+
+//#region src/adapters/hono/parse-query.d.ts
+declare function parsePaginationFromQuery(query: Record<string, string | undefined>, schema: z.ZodObject<Record<string, z.ZodTypeAny>>): Record<string, unknown>;
+declare function parseSortFromQuery(query: Record<string, string | undefined>, allowedFields?: readonly string[]): SortParams;
+//#endregion
+//#region src/adapters/hono/types.d.ts
+type HonoParseQueryOptions = {
+  paginationSchema?: _$zod.ZodObject<Record<string, _$zod.ZodTypeAny>>;
+  sortFields?: readonly string[];
+};
+//#endregion
+export { type HonoParseQueryOptions, parsePaginationFromQuery, parseSortFromQuery };

package/dist/hono.d.mts

@@ -0,0 +1,15 @@
+import { s as SortParams } from "./index-C4IwIpFc.mjs";
+import * as _$zod from "zod";
+import { z } from "zod";
+
+//#region src/adapters/hono/parse-query.d.ts
+declare function parsePaginationFromQuery(query: Record<string, string | undefined>, schema: z.ZodObject<Record<string, z.ZodTypeAny>>): Record<string, unknown>;
+declare function parseSortFromQuery(query: Record<string, string | undefined>, allowedFields?: readonly string[]): SortParams;
+//#endregion
+//#region src/adapters/hono/types.d.ts
+type HonoParseQueryOptions = {
+  paginationSchema?: _$zod.ZodObject<Record<string, _$zod.ZodTypeAny>>;
+  sortFields?: readonly string[];
+};
+//#endregion
+export { type HonoParseQueryOptions, parsePaginationFromQuery, parseSortFromQuery };

package/dist/hono.mjs

@@ -0,0 +1 @@
+import{z as e}from"zod";function t(e){if(e===void 0)return;let t=Number(e);return Number.isNaN(t)?void 0:t}function n(n,r){let i=r.shape,a={};for(let[r]of Object.entries(i))if(n[r]!==void 0){let o=i[r];o instanceof e.ZodNumber||o instanceof e.ZodOptional&&o.unwrap()instanceof e.ZodNumber?a[r]=t(n[r]):a[r]=n[r]}return r.parse(a)}function r(e,t){let n=e.sortBy,r=e.sortOrder;if(n&&t&&!t.includes(n))return{};if(r&&r!==`asc`&&r!==`desc`)return{sortBy:n};let i={};return n&&(i.sortBy=n),r&&(i.sortOrder=r),i}export{n as parsePaginationFromQuery,r as parseSortFromQuery};

package/dist/index-C4IwIpFc.d.mts

@@ -0,0 +1,199 @@
+import { z } from "zod";
+
+//#region src/schemas/pagination.schemas.d.ts
+declare const PaginationDefaultsSchema: z.ZodObject<{
+  page: z.ZodLiteral<1>;
+  pageSize: z.ZodLiteral<20>;
+  maxPageSize: z.ZodLiteral<100>;
+  minPageSize: z.ZodLiteral<1>;
+}, z.core.$strip>;
+type PaginationDefaults = z.infer<typeof PaginationDefaultsSchema>;
+declare const PaginationParamsSchema: z.ZodObject<{
+  page: z.ZodOptional<z.ZodNumber>;
+  pageSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type PaginationParams = z.infer<typeof PaginationParamsSchema>;
+declare const OffsetPaginationParamsSchema: z.ZodObject<{
+  limit: z.ZodOptional<z.ZodNumber>;
+  offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type OffsetPaginationParams = z.infer<typeof OffsetPaginationParamsSchema>;
+declare const CursorPaginationParamsSchema: z.ZodObject<{
+  cursor: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type CursorPaginationParams = z.infer<typeof CursorPaginationParamsSchema>;
+type CreatePaginationSchemaOptions = {
+  mode: 'page' | 'offset' | 'cursor';
+  pageSizeField?: string;
+  cursorField?: string;
+  fields?: {
+    page?: boolean;
+    pageSize?: boolean;
+    limit?: boolean;
+    offset?: boolean;
+    cursor?: boolean;
+  };
+};
+declare function createPaginationSchema(options: CreatePaginationSchemaOptions): z.ZodObject<{
+  page: z.ZodOptional<z.ZodNumber>;
+} | {
+  page?: undefined;
+}, z.core.$strip> | z.ZodObject<{
+  limit: z.ZodOptional<z.ZodNumber>;
+} | {
+  limit?: undefined;
+}, z.core.$strip>;
+//#endregion
+//#region src/types/pagination.types.d.ts
+declare const PAGINATION_DEFAULTS: {
+  readonly page: 1;
+  readonly pageSize: 20;
+  readonly maxPageSize: 100;
+  readonly minPageSize: 1;
+};
+//#endregion
+//#region src/schemas/result.schemas.d.ts
+declare function createPaginatedResultSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  page: z.ZodNumber;
+  pageSize: z.ZodNumber;
+  totalPages: z.ZodNumber;
+  hasNextPage: z.ZodBoolean;
+  hasPreviousPage: z.ZodBoolean;
+}, z.core.$strip>;
+type PaginatedResult<T> = {
+  items: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+  totalPages: number;
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+};
+declare function createOffsetPaginatedResultSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  limit: z.ZodNumber;
+  offset: z.ZodNumber;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+type OffsetPaginatedResult<T> = {
+  items: T[];
+  total: number;
+  limit: number;
+  offset: number;
+  hasMore: boolean;
+};
+declare function createCursorPaginatedResultSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+  items: z.ZodArray<T>;
+  nextCursor: z.ZodNullable<z.ZodString>;
+  previousCursor: z.ZodNullable<z.ZodString>;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+type CursorPaginatedResult<T> = {
+  items: T[];
+  nextCursor: string | null;
+  previousCursor: string | null;
+  hasMore: boolean;
+};
+type CompactPaginatedResult<T> = {
+  items: T[];
+  total: number;
+  hasMore: boolean;
+};
+declare function createCompactPaginatedResultSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+type CreateResultSchemaOptions = {
+  mode: 'page' | 'offset' | 'cursor' | 'compact';
+  pageSizeField?: string;
+  metadata?: ('total' | 'totalPages' | 'hasNextPage' | 'hasPreviousPage' | 'hasMore')[];
+};
+declare function createResultSchema<T extends z.ZodTypeAny>(itemSchema: T, options: CreateResultSchemaOptions): z.ZodObject<{
+  [x: string]: z.ZodNumber | z.ZodBoolean | z.ZodArray<T>;
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  page: z.ZodNumber;
+  totalPages: z.ZodNumber;
+  hasNextPage: z.ZodBoolean;
+  hasPreviousPage: z.ZodBoolean;
+}, z.core.$strip> | z.ZodObject<{
+  items: z.ZodArray<T>;
+  nextCursor: z.ZodNullable<z.ZodString>;
+  previousCursor: z.ZodNullable<z.ZodString>;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip> | z.ZodObject<{
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+//#endregion
+//#region src/schemas/sort.schemas.d.ts
+declare const SortOrderSchema: z.ZodEnum<{
+  asc: "asc";
+  desc: "desc";
+}>;
+type SortOrder = z.infer<typeof SortOrderSchema>;
+type SortParams<T extends string = string> = {
+  sortBy?: T;
+  sortOrder?: SortOrder;
+};
+declare function createSortParamsSchema<T extends [string, ...string[]]>(fields: T): z.ZodObject<{
+  sortBy: z.ZodOptional<z.ZodEnum<{ [k_1 in T[number]]: k_1 } extends infer T_1 ? { [k in keyof T_1]: T_1[k] } : never>>;
+  sortOrder: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+}, z.core.$strip>;
+declare const SortParamsSchema: z.ZodObject<{
+  sortBy: z.ZodOptional<z.ZodString>;
+  sortOrder: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+}, z.core.$strip>;
+type SortItem<T extends string = string> = {
+  field: T;
+  order: SortOrder;
+};
+declare function createSortItemSchema<T extends [string, ...string[]]>(fields: T): z.ZodObject<{
+  field: z.ZodEnum<{ [k_1 in T[number]]: k_1 } extends infer T_1 ? { [k in keyof T_1]: T_1[k] } : never>;
+  order: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>;
+}, z.core.$strip>;
+declare const SortItemSchema: z.ZodObject<{
+  field: z.ZodString;
+  order: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>;
+}, z.core.$strip>;
+type MultiSortParams<T extends string = string> = {
+  sort?: SortItem<T>[];
+};
+declare function createMultiSortParamsSchema<T extends [string, ...string[]]>(fields: T): z.ZodObject<{
+  sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    field: z.ZodEnum<{ [k_1 in T[number]]: k_1 } extends infer T_1 ? { [k in keyof T_1]: T_1[k] } : never>;
+    order: z.ZodEnum<{
+      asc: "asc";
+      desc: "desc";
+    }>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const MultiSortParamsSchema: z.ZodObject<{
+  sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    field: z.ZodString;
+    order: z.ZodEnum<{
+      asc: "asc";
+      desc: "desc";
+    }>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+//#endregion
+export { createPaginationSchema as A, CursorPaginationParamsSchema as C, PaginationDefaultsSchema as D, PaginationDefaults as E, PaginationParams as O, CursorPaginationParams as S, OffsetPaginationParamsSchema as T, createCursorPaginatedResultSchema as _, SortOrder as a, createResultSchema as b, SortParamsSchema as c, createSortParamsSchema as d, CompactPaginatedResult as f, createCompactPaginatedResultSchema as g, PaginatedResult as h, SortItemSchema as i, PaginationParamsSchema as k, createMultiSortParamsSchema as l, OffsetPaginatedResult as m, MultiSortParamsSchema as n, SortOrderSchema as o, CursorPaginatedResult as p, SortItem as r, SortParams as s, MultiSortParams as t, createSortItemSchema as u, createOffsetPaginatedResultSchema as v, OffsetPaginationParams as w, PAGINATION_DEFAULTS as x, createPaginatedResultSchema as y };

package/dist/index-DpbbjAwO.d.cts

@@ -0,0 +1,199 @@
+import { z } from "zod";
+
+//#region src/schemas/pagination.schemas.d.ts
+declare const PaginationDefaultsSchema: z.ZodObject<{
+  page: z.ZodLiteral<1>;
+  pageSize: z.ZodLiteral<20>;
+  maxPageSize: z.ZodLiteral<100>;
+  minPageSize: z.ZodLiteral<1>;
+}, z.core.$strip>;
+type PaginationDefaults = z.infer<typeof PaginationDefaultsSchema>;
+declare const PaginationParamsSchema: z.ZodObject<{
+  page: z.ZodOptional<z.ZodNumber>;
+  pageSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type PaginationParams = z.infer<typeof PaginationParamsSchema>;
+declare const OffsetPaginationParamsSchema: z.ZodObject<{
+  limit: z.ZodOptional<z.ZodNumber>;
+  offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type OffsetPaginationParams = z.infer<typeof OffsetPaginationParamsSchema>;
+declare const CursorPaginationParamsSchema: z.ZodObject<{
+  cursor: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type CursorPaginationParams = z.infer<typeof CursorPaginationParamsSchema>;
+type CreatePaginationSchemaOptions = {
+  mode: 'page' | 'offset' | 'cursor';
+  pageSizeField?: string;
+  cursorField?: string;
+  fields?: {
+    page?: boolean;
+    pageSize?: boolean;
+    limit?: boolean;
+    offset?: boolean;
+    cursor?: boolean;
+  };
+};
+declare function createPaginationSchema(options: CreatePaginationSchemaOptions): z.ZodObject<{
+  page: z.ZodOptional<z.ZodNumber>;
+} | {
+  page?: undefined;
+}, z.core.$strip> | z.ZodObject<{
+  limit: z.ZodOptional<z.ZodNumber>;
+} | {
+  limit?: undefined;
+}, z.core.$strip>;
+//#endregion
+//#region src/types/pagination.types.d.ts
+declare const PAGINATION_DEFAULTS: {
+  readonly page: 1;
+  readonly pageSize: 20;
+  readonly maxPageSize: 100;
+  readonly minPageSize: 1;
+};
+//#endregion
+//#region src/schemas/result.schemas.d.ts
+declare function createPaginatedResultSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  page: z.ZodNumber;
+  pageSize: z.ZodNumber;
+  totalPages: z.ZodNumber;
+  hasNextPage: z.ZodBoolean;
+  hasPreviousPage: z.ZodBoolean;
+}, z.core.$strip>;
+type PaginatedResult<T> = {
+  items: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+  totalPages: number;
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+};
+declare function createOffsetPaginatedResultSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  limit: z.ZodNumber;
+  offset: z.ZodNumber;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+type OffsetPaginatedResult<T> = {
+  items: T[];
+  total: number;
+  limit: number;
+  offset: number;
+  hasMore: boolean;
+};
+declare function createCursorPaginatedResultSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+  items: z.ZodArray<T>;
+  nextCursor: z.ZodNullable<z.ZodString>;
+  previousCursor: z.ZodNullable<z.ZodString>;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+type CursorPaginatedResult<T> = {
+  items: T[];
+  nextCursor: string | null;
+  previousCursor: string | null;
+  hasMore: boolean;
+};
+type CompactPaginatedResult<T> = {
+  items: T[];
+  total: number;
+  hasMore: boolean;
+};
+declare function createCompactPaginatedResultSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+type CreateResultSchemaOptions = {
+  mode: 'page' | 'offset' | 'cursor' | 'compact';
+  pageSizeField?: string;
+  metadata?: ('total' | 'totalPages' | 'hasNextPage' | 'hasPreviousPage' | 'hasMore')[];
+};
+declare function createResultSchema<T extends z.ZodTypeAny>(itemSchema: T, options: CreateResultSchemaOptions): z.ZodObject<{
+  [x: string]: z.ZodNumber | z.ZodBoolean | z.ZodArray<T>;
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  page: z.ZodNumber;
+  totalPages: z.ZodNumber;
+  hasNextPage: z.ZodBoolean;
+  hasPreviousPage: z.ZodBoolean;
+}, z.core.$strip> | z.ZodObject<{
+  items: z.ZodArray<T>;
+  nextCursor: z.ZodNullable<z.ZodString>;
+  previousCursor: z.ZodNullable<z.ZodString>;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip> | z.ZodObject<{
+  items: z.ZodArray<T>;
+  total: z.ZodNumber;
+  hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+//#endregion
+//#region src/schemas/sort.schemas.d.ts
+declare const SortOrderSchema: z.ZodEnum<{
+  asc: "asc";
+  desc: "desc";
+}>;
+type SortOrder = z.infer<typeof SortOrderSchema>;
+type SortParams<T extends string = string> = {
+  sortBy?: T;
+  sortOrder?: SortOrder;
+};
+declare function createSortParamsSchema<T extends [string, ...string[]]>(fields: T): z.ZodObject<{
+  sortBy: z.ZodOptional<z.ZodEnum<{ [k_1 in T[number]]: k_1 } extends infer T_1 ? { [k in keyof T_1]: T_1[k] } : never>>;
+  sortOrder: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+}, z.core.$strip>;
+declare const SortParamsSchema: z.ZodObject<{
+  sortBy: z.ZodOptional<z.ZodString>;
+  sortOrder: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+}, z.core.$strip>;
+type SortItem<T extends string = string> = {
+  field: T;
+  order: SortOrder;
+};
+declare function createSortItemSchema<T extends [string, ...string[]]>(fields: T): z.ZodObject<{
+  field: z.ZodEnum<{ [k_1 in T[number]]: k_1 } extends infer T_1 ? { [k in keyof T_1]: T_1[k] } : never>;
+  order: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>;
+}, z.core.$strip>;
+declare const SortItemSchema: z.ZodObject<{
+  field: z.ZodString;
+  order: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>;
+}, z.core.$strip>;
+type MultiSortParams<T extends string = string> = {
+  sort?: SortItem<T>[];
+};
+declare function createMultiSortParamsSchema<T extends [string, ...string[]]>(fields: T): z.ZodObject<{
+  sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    field: z.ZodEnum<{ [k_1 in T[number]]: k_1 } extends infer T_1 ? { [k in keyof T_1]: T_1[k] } : never>;
+    order: z.ZodEnum<{
+      asc: "asc";
+      desc: "desc";
+    }>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const MultiSortParamsSchema: z.ZodObject<{
+  sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    field: z.ZodString;
+    order: z.ZodEnum<{
+      asc: "asc";
+      desc: "desc";
+    }>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+//#endregion
+export { createPaginationSchema as A, CursorPaginationParamsSchema as C, PaginationDefaultsSchema as D, PaginationDefaults as E, PaginationParams as O, CursorPaginationParams as S, OffsetPaginationParamsSchema as T, createCursorPaginatedResultSchema as _, SortOrder as a, createResultSchema as b, SortParamsSchema as c, createSortParamsSchema as d, CompactPaginatedResult as f, createCompactPaginatedResultSchema as g, PaginatedResult as h, SortItemSchema as i, PaginationParamsSchema as k, createMultiSortParamsSchema as l, OffsetPaginatedResult as m, MultiSortParamsSchema as n, SortOrderSchema as o, CursorPaginatedResult as p, SortItem as r, SortParams as s, MultiSortParams as t, createSortItemSchema as u, createOffsetPaginatedResultSchema as v, OffsetPaginationParams as w, PAGINATION_DEFAULTS as x, createPaginatedResultSchema as y };