@nakanoaas/notion-valibot-schema 0.0.4 → 0.0.5

package/dist/select.d.cts

@@ -1,6 +1,67 @@
 import * as v from "valibot";
 
 //#region src/select.d.ts
+
+/**
+ * Schema factory to extract the `select` property from a Notion page property.
+ *
+ * This is a generic schema factory that accepts another schema as a parameter,
+ * allowing you to combine it with other schemas in this library to extract
+ * typed select values. The select property in Notion contains an object with
+ * a `name` field that can be validated using the provided schema.
+ *
+ * **Input:**
+ * ```
+ * {
+ *   select: {
+ *     name: string;
+ *   };
+ * }
+ * ```
+ *
+ * **Output:** The output type depends on the schema passed as a parameter.
+ * For example, if `v.string()` is passed, the output will be `string`.
+ *
+ * @param schema - A schema that validates the select option name.
+ *                  Must accept a string value.
+ *
+ * @example
+ * ```ts
+ * import * as v from "valibot";
+ * import { SelectSchema } from "@nakanoaas/notion-valibot-utils";
+ *
+ * const PageSchema = v.object({
+ *   id: v.string(),
+ *   properties: v.object({
+ *     Status: SelectSchema(v.string()),
+ *   }),
+ * });
+ *
+ * const page = await notion.pages.retrieve({ page_id: "..." });
+ * const parsed = v.parse(PageSchema, page);
+ * // parsed.properties.Status: string
+ * ```
+ *
+ * @example
+ * ```ts
+ * import * as v from "valibot";
+ * import { SelectSchema } from "@nakanoaas/notion-valibot-utils";
+ *
+ * // Custom schema for enum values
+ * const StatusSchema = v.picklist(["todo", "in-progress", "done"]);
+ *
+ * const PageSchema = v.object({
+ *   id: v.string(),
+ *   properties: v.object({
+ *     Status: SelectSchema(StatusSchema),
+ *   }),
+ * });
+ *
+ * const page = await notion.pages.retrieve({ page_id: "..." });
+ * const parsed = v.parse(PageSchema, page);
+ * // parsed.properties.Status: "todo" | "in-progress" | "done"
+ * ```
+ */
 declare function SelectSchema<T extends v.GenericSchema<string>>(schema: T): v.SchemaWithPipe<readonly [v.ObjectSchema<{
   readonly select: v.ObjectSchema<{
     readonly name: T;
@@ -32,6 +93,66 @@ declare function SelectSchema<T extends v.GenericSchema<string>>(schema: T): v.S
 }, T extends (v.ExactOptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown>) | (v.ExactOptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown>) ? undefined extends T["default"] ? "name" : never : never> & Partial<Pick<{
   name: v.InferOutput<T>;
 }, T extends (v.ExactOptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown>) | (v.ExactOptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown>) ? undefined extends T["default"] ? "name" : never : never>>, Exclude<"name", T extends v.SchemaWithPipe<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> | v.SchemaWithPipeAsync<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> ? v.ReadonlyAction<any> extends TPipe[number] ? "name" : never : never> | Exclude<T extends (v.ExactOptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown>) | (v.ExactOptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown>) ? undefined extends T["default"] ? "name" : never : never, T extends v.SchemaWithPipe<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> | v.SchemaWithPipeAsync<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> ? v.ReadonlyAction<any> extends TPipe[number] ? "name" : never : never> | Exclude<Exclude<"name", T extends (v.ExactOptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown>) | (v.ExactOptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown>) ? undefined extends T["default"] ? "name" : never : never>, T extends v.SchemaWithPipe<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> | v.SchemaWithPipeAsync<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> ? v.ReadonlyAction<any> extends TPipe[number] ? "name" : never : never>>)["name"]>]>;
+/**
+ * Schema factory to extract the `select` property from a Notion page property or `null`.
+ *
+ * This is a generic schema factory that accepts another schema as a parameter,
+ * allowing you to combine it with other schemas in this library to extract
+ * typed select values. The select property in Notion contains an object with
+ * a `name` field that can be validated using the provided schema, or `null` if not set.
+ *
+ * **Input:**
+ * ```
+ * {
+ *   select: {
+ *     name: string;
+ *   } | null;
+ * }
+ * ```
+ *
+ * **Output:** The output type depends on the schema passed as a parameter, or `null`.
+ * For example, if `v.string()` is passed, the output will be `string | null`.
+ *
+ * @param schema - A schema that validates the select option name.
+ *                  Must accept a string value.
+ *
+ * @example
+ * ```ts
+ * import * as v from "valibot";
+ * import { NullableSelectSchema } from "@nakanoaas/notion-valibot-utils";
+ *
+ * const PageSchema = v.object({
+ *   id: v.string(),
+ *   properties: v.object({
+ *     Status: NullableSelectSchema(v.string()),
+ *   }),
+ * });
+ *
+ * const page = await notion.pages.retrieve({ page_id: "..." });
+ * const parsed = v.parse(PageSchema, page);
+ * // parsed.properties.Status: string | null
+ * ```
+ *
+ * @example
+ * ```ts
+ * import * as v from "valibot";
+ * import { NullableSelectSchema } from "@nakanoaas/notion-valibot-utils";
+ *
+ * // Custom schema for enum values
+ * const StatusSchema = v.picklist(["todo", "in-progress", "done"]);
+ *
+ * const PageSchema = v.object({
+ *   id: v.string(),
+ *   properties: v.object({
+ *     Status: NullableSelectSchema(StatusSchema),
+ *   }),
+ * });
+ *
+ * const page = await notion.pages.retrieve({ page_id: "..." });
+ * const parsed = v.parse(PageSchema, page);
+ * // parsed.properties.Status: "todo" | "in-progress" | "done" | null
+ * ```
+ */
 declare function NullableSelectSchema<T extends v.GenericSchema<string>>(schema: T): v.SchemaWithPipe<readonly [v.ObjectSchema<{
   readonly select: v.NullableSchema<v.ObjectSchema<{
     readonly name: T;

package/dist/select.d.mts

@@ -1,6 +1,67 @@
 import * as v from "valibot";
 
 //#region src/select.d.ts
+
+/**
+ * Schema factory to extract the `select` property from a Notion page property.
+ *
+ * This is a generic schema factory that accepts another schema as a parameter,
+ * allowing you to combine it with other schemas in this library to extract
+ * typed select values. The select property in Notion contains an object with
+ * a `name` field that can be validated using the provided schema.
+ *
+ * **Input:**
+ * ```
+ * {
+ *   select: {
+ *     name: string;
+ *   };
+ * }
+ * ```
+ *
+ * **Output:** The output type depends on the schema passed as a parameter.
+ * For example, if `v.string()` is passed, the output will be `string`.
+ *
+ * @param schema - A schema that validates the select option name.
+ *                  Must accept a string value.
+ *
+ * @example
+ * ```ts
+ * import * as v from "valibot";
+ * import { SelectSchema } from "@nakanoaas/notion-valibot-utils";
+ *
+ * const PageSchema = v.object({
+ *   id: v.string(),
+ *   properties: v.object({
+ *     Status: SelectSchema(v.string()),
+ *   }),
+ * });
+ *
+ * const page = await notion.pages.retrieve({ page_id: "..." });
+ * const parsed = v.parse(PageSchema, page);
+ * // parsed.properties.Status: string
+ * ```
+ *
+ * @example
+ * ```ts
+ * import * as v from "valibot";
+ * import { SelectSchema } from "@nakanoaas/notion-valibot-utils";
+ *
+ * // Custom schema for enum values
+ * const StatusSchema = v.picklist(["todo", "in-progress", "done"]);
+ *
+ * const PageSchema = v.object({
+ *   id: v.string(),
+ *   properties: v.object({
+ *     Status: SelectSchema(StatusSchema),
+ *   }),
+ * });
+ *
+ * const page = await notion.pages.retrieve({ page_id: "..." });
+ * const parsed = v.parse(PageSchema, page);
+ * // parsed.properties.Status: "todo" | "in-progress" | "done"
+ * ```
+ */
 declare function SelectSchema<T extends v.GenericSchema<string>>(schema: T): v.SchemaWithPipe<readonly [v.ObjectSchema<{
   readonly select: v.ObjectSchema<{
     readonly name: T;
@@ -32,6 +93,66 @@ declare function SelectSchema<T extends v.GenericSchema<string>>(schema: T): v.S
 }, T extends (v.ExactOptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown>) | (v.ExactOptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown>) ? undefined extends T["default"] ? "name" : never : never> & Partial<Pick<{
   name: v.InferOutput<T>;
 }, T extends (v.ExactOptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown>) | (v.ExactOptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown>) ? undefined extends T["default"] ? "name" : never : never>>, Exclude<"name", T extends v.SchemaWithPipe<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> | v.SchemaWithPipeAsync<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> ? v.ReadonlyAction<any> extends TPipe[number] ? "name" : never : never> | Exclude<T extends (v.ExactOptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown>) | (v.ExactOptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown>) ? undefined extends T["default"] ? "name" : never : never, T extends v.SchemaWithPipe<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> | v.SchemaWithPipeAsync<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> ? v.ReadonlyAction<any> extends TPipe[number] ? "name" : never : never> | Exclude<Exclude<"name", T extends (v.ExactOptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchema<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, unknown>) | (v.ExactOptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.NullishSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown> | v.OptionalSchemaAsync<v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, unknown>) ? undefined extends T["default"] ? "name" : never : never>, T extends v.SchemaWithPipe<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> | v.SchemaWithPipeAsync<infer TPipe extends readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>, ...v.PipeItem<any, unknown, v.BaseIssue<unknown>>[]] & readonly [v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>, ...(v.PipeItem<any, unknown, v.BaseIssue<unknown>> | v.PipeItemAsync<any, unknown, v.BaseIssue<unknown>>)[]]> ? v.ReadonlyAction<any> extends TPipe[number] ? "name" : never : never>>)["name"]>]>;
+/**
+ * Schema factory to extract the `select` property from a Notion page property or `null`.
+ *
+ * This is a generic schema factory that accepts another schema as a parameter,
+ * allowing you to combine it with other schemas in this library to extract
+ * typed select values. The select property in Notion contains an object with
+ * a `name` field that can be validated using the provided schema, or `null` if not set.
+ *
+ * **Input:**
+ * ```
+ * {
+ *   select: {
+ *     name: string;
+ *   } | null;
+ * }
+ * ```
+ *
+ * **Output:** The output type depends on the schema passed as a parameter, or `null`.
+ * For example, if `v.string()` is passed, the output will be `string | null`.
+ *
+ * @param schema - A schema that validates the select option name.
+ *                  Must accept a string value.
+ *
+ * @example
+ * ```ts
+ * import * as v from "valibot";
+ * import { NullableSelectSchema } from "@nakanoaas/notion-valibot-utils";
+ *
+ * const PageSchema = v.object({
+ *   id: v.string(),
+ *   properties: v.object({
+ *     Status: NullableSelectSchema(v.string()),
+ *   }),
+ * });
+ *
+ * const page = await notion.pages.retrieve({ page_id: "..." });
+ * const parsed = v.parse(PageSchema, page);
+ * // parsed.properties.Status: string | null
+ * ```
+ *
+ * @example
+ * ```ts
+ * import * as v from "valibot";
+ * import { NullableSelectSchema } from "@nakanoaas/notion-valibot-utils";
+ *
+ * // Custom schema for enum values
+ * const StatusSchema = v.picklist(["todo", "in-progress", "done"]);
+ *
+ * const PageSchema = v.object({
+ *   id: v.string(),
+ *   properties: v.object({
+ *     Status: NullableSelectSchema(StatusSchema),
+ *   }),
+ * });
+ *
+ * const page = await notion.pages.retrieve({ page_id: "..." });
+ * const parsed = v.parse(PageSchema, page);
+ * // parsed.properties.Status: "todo" | "in-progress" | "done" | null
+ * ```
+ */
 declare function NullableSelectSchema<T extends v.GenericSchema<string>>(schema: T): v.SchemaWithPipe<readonly [v.ObjectSchema<{
   readonly select: v.NullableSchema<v.ObjectSchema<{
     readonly name: T;

package/dist/select.mjs

@@ -1,9 +1,129 @@
 import * as v from "valibot";
 
 //#region src/select.ts
+/**
+* Schema factory to extract the `select` property from a Notion page property.
+*
+* This is a generic schema factory that accepts another schema as a parameter,
+* allowing you to combine it with other schemas in this library to extract
+* typed select values. The select property in Notion contains an object with
+* a `name` field that can be validated using the provided schema.
+*
+* **Input:**
+* ```
+* {
+*   select: {
+*     name: string;
+*   };
+* }
+* ```
+*
+* **Output:** The output type depends on the schema passed as a parameter.
+* For example, if `v.string()` is passed, the output will be `string`.
+*
+* @param schema - A schema that validates the select option name.
+*                  Must accept a string value.
+*
+* @example
+* ```ts
+* import * as v from "valibot";
+* import { SelectSchema } from "@nakanoaas/notion-valibot-utils";
+*
+* const PageSchema = v.object({
+*   id: v.string(),
+*   properties: v.object({
+*     Status: SelectSchema(v.string()),
+*   }),
+* });
+*
+* const page = await notion.pages.retrieve({ page_id: "..." });
+* const parsed = v.parse(PageSchema, page);
+* // parsed.properties.Status: string
+* ```
+*
+* @example
+* ```ts
+* import * as v from "valibot";
+* import { SelectSchema } from "@nakanoaas/notion-valibot-utils";
+*
+* // Custom schema for enum values
+* const StatusSchema = v.picklist(["todo", "in-progress", "done"]);
+*
+* const PageSchema = v.object({
+*   id: v.string(),
+*   properties: v.object({
+*     Status: SelectSchema(StatusSchema),
+*   }),
+* });
+*
+* const page = await notion.pages.retrieve({ page_id: "..." });
+* const parsed = v.parse(PageSchema, page);
+* // parsed.properties.Status: "todo" | "in-progress" | "done"
+* ```
+*/
 function SelectSchema(schema) {
 	return v.pipe(v.object({ select: v.object({ name: schema }) }), v.transform((v$1) => v$1.select.name));
 }
+/**
+* Schema factory to extract the `select` property from a Notion page property or `null`.
+*
+* This is a generic schema factory that accepts another schema as a parameter,
+* allowing you to combine it with other schemas in this library to extract
+* typed select values. The select property in Notion contains an object with
+* a `name` field that can be validated using the provided schema, or `null` if not set.
+*
+* **Input:**
+* ```
+* {
+*   select: {
+*     name: string;
+*   } | null;
+* }
+* ```
+*
+* **Output:** The output type depends on the schema passed as a parameter, or `null`.
+* For example, if `v.string()` is passed, the output will be `string | null`.
+*
+* @param schema - A schema that validates the select option name.
+*                  Must accept a string value.
+*
+* @example
+* ```ts
+* import * as v from "valibot";
+* import { NullableSelectSchema } from "@nakanoaas/notion-valibot-utils";
+*
+* const PageSchema = v.object({
+*   id: v.string(),
+*   properties: v.object({
+*     Status: NullableSelectSchema(v.string()),
+*   }),
+* });
+*
+* const page = await notion.pages.retrieve({ page_id: "..." });
+* const parsed = v.parse(PageSchema, page);
+* // parsed.properties.Status: string | null
+* ```
+*
+* @example
+* ```ts
+* import * as v from "valibot";
+* import { NullableSelectSchema } from "@nakanoaas/notion-valibot-utils";
+*
+* // Custom schema for enum values
+* const StatusSchema = v.picklist(["todo", "in-progress", "done"]);
+*
+* const PageSchema = v.object({
+*   id: v.string(),
+*   properties: v.object({
+*     Status: NullableSelectSchema(StatusSchema),
+*   }),
+* });
+*
+* const page = await notion.pages.retrieve({ page_id: "..." });
+* const parsed = v.parse(PageSchema, page);
+* // parsed.properties.Status: "todo" | "in-progress" | "done" | null
+* ```
+*/
 function NullableSelectSchema(schema) {
 	return v.pipe(v.object({ select: v.nullable(v.object({ name: schema })) }), v.transform((v$1) => v$1.select?.name ?? null));
 }

package/dist/select.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"select.mjs","names":["v"],"sources":["../src/select.ts"],"sourcesContent":["import * as v from \"valibot\";\n\nexport function SelectSchema<T extends v.GenericSchema<string>>(schema: T) {\n\treturn v.pipe(\n\t\tv.object({\n\t\t\tselect: v.object({\n\t\t\t\tname: schema,\n\t\t\t}),\n\t\t}),\n\t\t// biome-ignore lint/style/noNonNullAssertion: valibot inference is not working correctly\n\t\tv.transform((v) => v.select.name!),\n\t);\n}\n\nexport function NullableSelectSchema<T extends v.GenericSchema<string>>(\n\tschema: T,\n) {\n\treturn v.pipe(\n\t\tv.object({\n\t\t\tselect: v.nullable(\n\t\t\t\tv.object({\n\t\t\t\t\tname: schema,\n\t\t\t\t}),\n\t\t\t),\n\t\t}),\n\t\tv.transform((v) => v.select?.name ?? null),\n\t);\n}\n"],"mappings":";;;AAEA,SAAgB,aAAgD,QAAW;AAC1E,QAAO,EAAE,KACR,EAAE,OAAO,EACR,QAAQ,EAAE,OAAO,EAChB,MAAM,QACN,CAAC,EACF,CAAC,EAEF,EAAE,WAAW,QAAMA,IAAE,OAAO,KAAM,CAClC;;AAGF,SAAgB,qBACf,QACC;AACD,QAAO,EAAE,KACR,EAAE,OAAO,EACR,QAAQ,EAAE,SACT,EAAE,OAAO,EACR,MAAM,QACN,CAAC,CACF,EACD,CAAC,EACF,EAAE,WAAW,QAAMA,IAAE,QAAQ,QAAQ,KAAK,CAC1C"}
+{"version":3,"file":"select.mjs","names":["v"],"sources":["../src/select.ts"],"sourcesContent":["import * as v from \"valibot\";\n\n/**\n * Schema factory to extract the `select` property from a Notion page property.\n *\n * This is a generic schema factory that accepts another schema as a parameter,\n * allowing you to combine it with other schemas in this library to extract\n * typed select values. The select property in Notion contains an object with\n * a `name` field that can be validated using the provided schema.\n *\n * **Input:**\n * ```\n * {\n *   select: {\n *     name: string;\n *   };\n * }\n * ```\n *\n * **Output:** The output type depends on the schema passed as a parameter.\n * For example, if `v.string()` is passed, the output will be `string`.\n *\n * @param schema - A schema that validates the select option name.\n *                  Must accept a string value.\n *\n * @example\n * ```ts\n * import * as v from \"valibot\";\n * import { SelectSchema } from \"@nakanoaas/notion-valibot-utils\";\n *\n * const PageSchema = v.object({\n *   id: v.string(),\n *   properties: v.object({\n *     Status: SelectSchema(v.string()),\n *   }),\n * });\n *\n * const page = await notion.pages.retrieve({ page_id: \"...\" });\n * const parsed = v.parse(PageSchema, page);\n * // parsed.properties.Status: string\n * ```\n *\n * @example\n * ```ts\n * import * as v from \"valibot\";\n * import { SelectSchema } from \"@nakanoaas/notion-valibot-utils\";\n *\n * // Custom schema for enum values\n * const StatusSchema = v.picklist([\"todo\", \"in-progress\", \"done\"]);\n *\n * const PageSchema = v.object({\n *   id: v.string(),\n *   properties: v.object({\n *     Status: SelectSchema(StatusSchema),\n *   }),\n * });\n *\n * const page = await notion.pages.retrieve({ page_id: \"...\" });\n * const parsed = v.parse(PageSchema, page);\n * // parsed.properties.Status: \"todo\" | \"in-progress\" | \"done\"\n * ```\n */\nexport function SelectSchema<T extends v.GenericSchema<string>>(schema: T) {\n\treturn v.pipe(\n\t\tv.object({\n\t\t\tselect: v.object({\n\t\t\t\tname: schema,\n\t\t\t}),\n\t\t}),\n\t\t// biome-ignore lint/style/noNonNullAssertion: valibot inference is not working correctly\n\t\tv.transform((v) => v.select.name!),\n\t);\n}\n\n/**\n * Schema factory to extract the `select` property from a Notion page property or `null`.\n *\n * This is a generic schema factory that accepts another schema as a parameter,\n * allowing you to combine it with other schemas in this library to extract\n * typed select values. The select property in Notion contains an object with\n * a `name` field that can be validated using the provided schema, or `null` if not set.\n *\n * **Input:**\n * ```\n * {\n *   select: {\n *     name: string;\n *   } | null;\n * }\n * ```\n *\n * **Output:** The output type depends on the schema passed as a parameter, or `null`.\n * For example, if `v.string()` is passed, the output will be `string | null`.\n *\n * @param schema - A schema that validates the select option name.\n *                  Must accept a string value.\n *\n * @example\n * ```ts\n * import * as v from \"valibot\";\n * import { NullableSelectSchema } from \"@nakanoaas/notion-valibot-utils\";\n *\n * const PageSchema = v.object({\n *   id: v.string(),\n *   properties: v.object({\n *     Status: NullableSelectSchema(v.string()),\n *   }),\n * });\n *\n * const page = await notion.pages.retrieve({ page_id: \"...\" });\n * const parsed = v.parse(PageSchema, page);\n * // parsed.properties.Status: string | null\n * ```\n *\n * @example\n * ```ts\n * import * as v from \"valibot\";\n * import { NullableSelectSchema } from \"@nakanoaas/notion-valibot-utils\";\n *\n * // Custom schema for enum values\n * const StatusSchema = v.picklist([\"todo\", \"in-progress\", \"done\"]);\n *\n * const PageSchema = v.object({\n *   id: v.string(),\n *   properties: v.object({\n *     Status: NullableSelectSchema(StatusSchema),\n *   }),\n * });\n *\n * const page = await notion.pages.retrieve({ page_id: \"...\" });\n * const parsed = v.parse(PageSchema, page);\n * // parsed.properties.Status: \"todo\" | \"in-progress\" | \"done\" | null\n * ```\n */\nexport function NullableSelectSchema<T extends v.GenericSchema<string>>(\n\tschema: T,\n) {\n\treturn v.pipe(\n\t\tv.object({\n\t\t\tselect: v.nullable(\n\t\t\t\tv.object({\n\t\t\t\t\tname: schema,\n\t\t\t\t}),\n\t\t\t),\n\t\t}),\n\t\tv.transform((v) => v.select?.name ?? null),\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,aAAgD,QAAW;AAC1E,QAAO,EAAE,KACR,EAAE,OAAO,EACR,QAAQ,EAAE,OAAO,EAChB,MAAM,QACN,CAAC,EACF,CAAC,EAEF,EAAE,WAAW,QAAMA,IAAE,OAAO,KAAM,CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DF,SAAgB,qBACf,QACC;AACD,QAAO,EAAE,KACR,EAAE,OAAO,EACR,QAAQ,EAAE,SACT,EAAE,OAAO,EACR,MAAM,QACN,CAAC,CACF,EACD,CAAC,EACF,EAAE,WAAW,QAAMA,IAAE,QAAQ,QAAQ,KAAK,CAC1C"}

package/dist/status.cjs

@@ -3,9 +3,129 @@ let valibot = require("valibot");
 valibot = require_rolldown_runtime.__toESM(valibot);
 
 //#region src/status.ts
+/**
+* Schema factory to extract the `status` property from a Notion page property.
+*
+* This is a generic schema factory that accepts another schema as a parameter,
+* allowing you to combine it with other schemas in this library to extract
+* typed status values. The status property in Notion contains an object with
+* a `name` field that can be validated using the provided schema.
+*
+* **Input:**
+* ```
+* {
+*   status: {
+*     name: string;
+*   };
+* }
+* ```
+*
+* **Output:** The output type depends on the schema passed as a parameter.
+* For example, if `v.string()` is passed, the output will be `string`.
+*
+* @param schema - A schema that validates the status option name.
+*                  Must accept a string value.
+*
+* @example
+* ```ts
+* import * as v from "valibot";
+* import { StatusSchema } from "@nakanoaas/notion-valibot-utils";
+*
+* const PageSchema = v.object({
+*   id: v.string(),
+*   properties: v.object({
+*     Status: StatusSchema(v.string()),
+*   }),
+* });
+*
+* const page = await notion.pages.retrieve({ page_id: "..." });
+* const parsed = v.parse(PageSchema, page);
+* // parsed.properties.Status: string
+* ```
+*
+* @example
+* ```ts
+* import * as v from "valibot";
+* import { StatusSchema } from "@nakanoaas/notion-valibot-utils";
+*
+* // Custom schema for enum values
+* const StatusOptionSchema = v.picklist(["not-started", "in-progress", "completed"]);
+*
+* const PageSchema = v.object({
+*   id: v.string(),
+*   properties: v.object({
+*     Status: StatusSchema(StatusOptionSchema),
+*   }),
+* });
+*
+* const page = await notion.pages.retrieve({ page_id: "..." });
+* const parsed = v.parse(PageSchema, page);
+* // parsed.properties.Status: "not-started" | "in-progress" | "completed"
+* ```
+*/
 function StatusSchema(schema) {
 	return valibot.pipe(valibot.object({ status: valibot.object({ name: schema }) }), valibot.transform((v) => v.status.name));
 }
+/**
+* Schema factory to extract the `status` property from a Notion page property or `null`.
+*
+* This is a generic schema factory that accepts another schema as a parameter,
+* allowing you to combine it with other schemas in this library to extract
+* typed status values. The status property in Notion contains an object with
+* a `name` field that can be validated using the provided schema, or `null` if not set.
+*
+* **Input:**
+* ```
+* {
+*   status: {
+*     name: string;
+*   } | null;
+* }
+* ```
+*
+* **Output:** The output type depends on the schema passed as a parameter, or `null`.
+* For example, if `v.string()` is passed, the output will be `string | null`.
+*
+* @param schema - A schema that validates the status option name.
+*                  Must accept a string value.
+*
+* @example
+* ```ts
+* import * as v from "valibot";
+* import { NullableStatusSchema } from "@nakanoaas/notion-valibot-utils";
+*
+* const PageSchema = v.object({
+*   id: v.string(),
+*   properties: v.object({
+*     Status: NullableStatusSchema(v.string()),
+*   }),
+* });
+*
+* const page = await notion.pages.retrieve({ page_id: "..." });
+* const parsed = v.parse(PageSchema, page);
+* // parsed.properties.Status: string | null
+* ```
+*
+* @example
+* ```ts
+* import * as v from "valibot";
+* import { NullableStatusSchema } from "@nakanoaas/notion-valibot-utils";
+*
+* // Custom schema for enum values
+* const StatusOptionSchema = v.picklist(["not-started", "in-progress", "completed"]);
+*
+* const PageSchema = v.object({
+*   id: v.string(),
+*   properties: v.object({
+*     Status: NullableStatusSchema(StatusOptionSchema),
+*   }),
+* });
+*
+* const page = await notion.pages.retrieve({ page_id: "..." });
+* const parsed = v.parse(PageSchema, page);
+* // parsed.properties.Status: "not-started" | "in-progress" | "completed" | null
+* ```
+*/
 function NullableStatusSchema(schema) {
 	return valibot.pipe(valibot.object({ status: valibot.nullable(valibot.object({ name: schema })) }), valibot.transform((v) => v.status?.name ?? null));
 }

package/dist/status.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"status.cjs","names":["v"],"sources":["../src/status.ts"],"sourcesContent":["import * as v from \"valibot\";\n\nexport function StatusSchema<T extends v.GenericSchema<string>>(schema: T) {\n\treturn v.pipe(\n\t\tv.object({\n\t\t\tstatus: v.object({\n\t\t\t\tname: schema,\n\t\t\t}),\n\t\t}),\n\t\t// biome-ignore lint/style/noNonNullAssertion: valibot inference is not working correctly\n\t\tv.transform((v) => v.status.name!),\n\t);\n}\n\nexport function NullableStatusSchema<T extends v.GenericSchema<string>>(\n\tschema: T,\n) {\n\treturn v.pipe(\n\t\tv.object({\n\t\t\tstatus: v.nullable(\n\t\t\t\tv.object({\n\t\t\t\t\tname: schema,\n\t\t\t\t}),\n\t\t\t),\n\t\t}),\n\t\tv.transform((v) => v.status?.name ?? null),\n\t);\n}\n"],"mappings":";;;;;AAEA,SAAgB,aAAgD,QAAW;AAC1E,QAAOA,QAAE,KACRA,QAAE,OAAO,EACR,QAAQA,QAAE,OAAO,EAChB,MAAM,QACN,CAAC,EACF,CAAC,EAEFA,QAAE,WAAW,MAAM,EAAE,OAAO,KAAM,CAClC;;AAGF,SAAgB,qBACf,QACC;AACD,QAAOA,QAAE,KACRA,QAAE,OAAO,EACR,QAAQA,QAAE,SACTA,QAAE,OAAO,EACR,MAAM,QACN,CAAC,CACF,EACD,CAAC,EACFA,QAAE,WAAW,MAAM,EAAE,QAAQ,QAAQ,KAAK,CAC1C"}
+{"version":3,"file":"status.cjs","names":["v"],"sources":["../src/status.ts"],"sourcesContent":["import * as v from \"valibot\";\n\n/**\n * Schema factory to extract the `status` property from a Notion page property.\n *\n * This is a generic schema factory that accepts another schema as a parameter,\n * allowing you to combine it with other schemas in this library to extract\n * typed status values. The status property in Notion contains an object with\n * a `name` field that can be validated using the provided schema.\n *\n * **Input:**\n * ```\n * {\n *   status: {\n *     name: string;\n *   };\n * }\n * ```\n *\n * **Output:** The output type depends on the schema passed as a parameter.\n * For example, if `v.string()` is passed, the output will be `string`.\n *\n * @param schema - A schema that validates the status option name.\n *                  Must accept a string value.\n *\n * @example\n * ```ts\n * import * as v from \"valibot\";\n * import { StatusSchema } from \"@nakanoaas/notion-valibot-utils\";\n *\n * const PageSchema = v.object({\n *   id: v.string(),\n *   properties: v.object({\n *     Status: StatusSchema(v.string()),\n *   }),\n * });\n *\n * const page = await notion.pages.retrieve({ page_id: \"...\" });\n * const parsed = v.parse(PageSchema, page);\n * // parsed.properties.Status: string\n * ```\n *\n * @example\n * ```ts\n * import * as v from \"valibot\";\n * import { StatusSchema } from \"@nakanoaas/notion-valibot-utils\";\n *\n * // Custom schema for enum values\n * const StatusOptionSchema = v.picklist([\"not-started\", \"in-progress\", \"completed\"]);\n *\n * const PageSchema = v.object({\n *   id: v.string(),\n *   properties: v.object({\n *     Status: StatusSchema(StatusOptionSchema),\n *   }),\n * });\n *\n * const page = await notion.pages.retrieve({ page_id: \"...\" });\n * const parsed = v.parse(PageSchema, page);\n * // parsed.properties.Status: \"not-started\" | \"in-progress\" | \"completed\"\n * ```\n */\nexport function StatusSchema<T extends v.GenericSchema<string>>(schema: T) {\n\treturn v.pipe(\n\t\tv.object({\n\t\t\tstatus: v.object({\n\t\t\t\tname: schema,\n\t\t\t}),\n\t\t}),\n\t\t// biome-ignore lint/style/noNonNullAssertion: valibot inference is not working correctly\n\t\tv.transform((v) => v.status.name!),\n\t);\n}\n\n/**\n * Schema factory to extract the `status` property from a Notion page property or `null`.\n *\n * This is a generic schema factory that accepts another schema as a parameter,\n * allowing you to combine it with other schemas in this library to extract\n * typed status values. The status property in Notion contains an object with\n * a `name` field that can be validated using the provided schema, or `null` if not set.\n *\n * **Input:**\n * ```\n * {\n *   status: {\n *     name: string;\n *   } | null;\n * }\n * ```\n *\n * **Output:** The output type depends on the schema passed as a parameter, or `null`.\n * For example, if `v.string()` is passed, the output will be `string | null`.\n *\n * @param schema - A schema that validates the status option name.\n *                  Must accept a string value.\n *\n * @example\n * ```ts\n * import * as v from \"valibot\";\n * import { NullableStatusSchema } from \"@nakanoaas/notion-valibot-utils\";\n *\n * const PageSchema = v.object({\n *   id: v.string(),\n *   properties: v.object({\n *     Status: NullableStatusSchema(v.string()),\n *   }),\n * });\n *\n * const page = await notion.pages.retrieve({ page_id: \"...\" });\n * const parsed = v.parse(PageSchema, page);\n * // parsed.properties.Status: string | null\n * ```\n *\n * @example\n * ```ts\n * import * as v from \"valibot\";\n * import { NullableStatusSchema } from \"@nakanoaas/notion-valibot-utils\";\n *\n * // Custom schema for enum values\n * const StatusOptionSchema = v.picklist([\"not-started\", \"in-progress\", \"completed\"]);\n *\n * const PageSchema = v.object({\n *   id: v.string(),\n *   properties: v.object({\n *     Status: NullableStatusSchema(StatusOptionSchema),\n *   }),\n * });\n *\n * const page = await notion.pages.retrieve({ page_id: \"...\" });\n * const parsed = v.parse(PageSchema, page);\n * // parsed.properties.Status: \"not-started\" | \"in-progress\" | \"completed\" | null\n * ```\n */\nexport function NullableStatusSchema<T extends v.GenericSchema<string>>(\n\tschema: T,\n) {\n\treturn v.pipe(\n\t\tv.object({\n\t\t\tstatus: v.nullable(\n\t\t\t\tv.object({\n\t\t\t\t\tname: schema,\n\t\t\t\t}),\n\t\t\t),\n\t\t}),\n\t\tv.transform((v) => v.status?.name ?? null),\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,aAAgD,QAAW;AAC1E,QAAOA,QAAE,KACRA,QAAE,OAAO,EACR,QAAQA,QAAE,OAAO,EAChB,MAAM,QACN,CAAC,EACF,CAAC,EAEFA,QAAE,WAAW,MAAM,EAAE,OAAO,KAAM,CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DF,SAAgB,qBACf,QACC;AACD,QAAOA,QAAE,KACRA,QAAE,OAAO,EACR,QAAQA,QAAE,SACTA,QAAE,OAAO,EACR,MAAM,QACN,CAAC,CACF,EACD,CAAC,EACFA,QAAE,WAAW,MAAM,EAAE,QAAQ,QAAQ,KAAK,CAC1C"}