@storyblok/schema 0.1.0-alpha.0

package/dist/generated/types/_utils.d.cts

@@ -0,0 +1,7 @@
+//#region src/generated/types/_utils.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/** Replaces the keys of `T` that also appear in `U` with the definitions from `U`. */
+type Override<T, U> = Prettify<Omit<T, keyof U> & U>;
+//#endregion
+export { Override, Prettify };
+//# sourceMappingURL=_utils.d.cts.map

package/dist/generated/types/_utils.d.mts

@@ -0,0 +1,7 @@
+//#region src/generated/types/_utils.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/** Replaces the keys of `T` that also appear in `U` with the definitions from `U`. */
+type Override<T, U> = Prettify<Omit<T, keyof U> & U>;
+//#endregion
+export { Override, Prettify };
+//# sourceMappingURL=_utils.d.mts.map

package/dist/generated/types/block.d.cts

@@ -0,0 +1,46 @@
+import { Component, ComponentCreate, ComponentUpdate } from "../mapi/_internal.gen.cjs";
+import { Field } from "../overlay/_internal.gen.cjs";
+import { Override } from "./_utils.cjs";
+
+//#region src/generated/types/block.d.ts
+/** Input form: an ordered array of named fields. The array index becomes `pos`. */
+type BlockSchemaInput = ReadonlyArray<Field & {
+  name: string;
+  required?: boolean;
+}>;
+/** Wire form: the MAPI object map keyed by field name. This is what `defineBlock` returns. */
+type BlockSchema = Record<string, Field & {
+  required?: boolean;
+}>;
+/** Converts an array-form schema input into the wire-shape object map at the type level. */
+type SchemaArrayToRecord<T extends BlockSchemaInput> = { [F in T[number] as F['name']]: Omit<F, 'name'> };
+/** A Storyblok block. */
+type Block<TName extends string = string, TBlockSchema extends BlockSchema = BlockSchema, TIsRoot extends boolean = boolean, TIsNestable extends boolean = boolean, TComponentGroupUuid extends string | null = string | null> = Override<Component, {
+  name: TName;
+  schema: TBlockSchema;
+  is_root?: TIsRoot;
+  is_nestable?: TIsNestable;
+  component_group_uuid?: TComponentGroupUuid;
+}>;
+/**
+ * A root {@link Block} (`is_root: true`). Given a union of blocks, narrows to
+ * its root members; with no argument it is the generic root-block type.
+ */
+type RootBlock<T extends Block = Block & {
+  is_root: true;
+}> = Extract<T, {
+  is_root: true;
+}>;
+/**
+ * A nestable {@link Block} (`is_nestable: true`). Given a union of blocks,
+ * narrows to its nestable members; with no argument it is the generic
+ * nestable-block type.
+ */
+type NestableBlock<T extends Block = Block & {
+  is_nestable: true;
+}> = Extract<T, {
+  is_nestable: true;
+}>;
+//#endregion
+export { Block, BlockSchema, BlockSchemaInput, NestableBlock, RootBlock, SchemaArrayToRecord };
+//# sourceMappingURL=block.d.cts.map

package/dist/generated/types/block.d.mts

@@ -0,0 +1,46 @@
+import { Component, ComponentCreate, ComponentUpdate } from "../mapi/_internal.gen.mjs";
+import { Field } from "../overlay/_internal.gen.mjs";
+import { Override } from "./_utils.mjs";
+
+//#region src/generated/types/block.d.ts
+/** Input form: an ordered array of named fields. The array index becomes `pos`. */
+type BlockSchemaInput = ReadonlyArray<Field & {
+  name: string;
+  required?: boolean;
+}>;
+/** Wire form: the MAPI object map keyed by field name. This is what `defineBlock` returns. */
+type BlockSchema = Record<string, Field & {
+  required?: boolean;
+}>;
+/** Converts an array-form schema input into the wire-shape object map at the type level. */
+type SchemaArrayToRecord<T extends BlockSchemaInput> = { [F in T[number] as F['name']]: Omit<F, 'name'> };
+/** A Storyblok block. */
+type Block<TName extends string = string, TBlockSchema extends BlockSchema = BlockSchema, TIsRoot extends boolean = boolean, TIsNestable extends boolean = boolean, TComponentGroupUuid extends string | null = string | null> = Override<Component, {
+  name: TName;
+  schema: TBlockSchema;
+  is_root?: TIsRoot;
+  is_nestable?: TIsNestable;
+  component_group_uuid?: TComponentGroupUuid;
+}>;
+/**
+ * A root {@link Block} (`is_root: true`). Given a union of blocks, narrows to
+ * its root members; with no argument it is the generic root-block type.
+ */
+type RootBlock<T extends Block = Block & {
+  is_root: true;
+}> = Extract<T, {
+  is_root: true;
+}>;
+/**
+ * A nestable {@link Block} (`is_nestable: true`). Given a union of blocks,
+ * narrows to its nestable members; with no argument it is the generic
+ * nestable-block type.
+ */
+type NestableBlock<T extends Block = Block & {
+  is_nestable: true;
+}> = Extract<T, {
+  is_nestable: true;
+}>;
+//#endregion
+export { Block, BlockSchema, BlockSchemaInput, NestableBlock, RootBlock, SchemaArrayToRecord };
+//# sourceMappingURL=block.d.mts.map

package/dist/generated/types/field.d.cts

@@ -0,0 +1,74 @@
+import { AssetFieldValue, BlockContentBase, BlockContentInputBase, Field, MultilinkFieldValue, PluginFieldValue, RichtextFieldValue, TableFieldValue } from "../overlay/_internal.gen.cjs";
+import { Prettify } from "./_utils.cjs";
+import { Block } from "./block.cjs";
+
+//#region src/generated/types/field.d.ts
+/**
+ * Registry of all blocks in the space, used to resolve nested `bloks` fields.
+ * A `Block` union resolves nested content against the registry; `NoBlocks`
+ * (the default) leaves it loose (`BlockContentBase`).
+ */
+type NoBlocks = false;
+/** True when `T` is the un-narrowed base `Block` (i.e. no specific block was supplied). */
+type IsBaseBlock<T> = [Block] extends [T] ? true : false;
+type RequiredFieldKeys<T> = { [K in keyof T]: T[K] extends {
+  required: true;
+} ? K : never }[keyof T];
+type OptionalFieldKeys<T> = Exclude<keyof T, RequiredFieldKeys<T>>;
+/**
+ * Content object for a single block instance as returned by the Storyblok
+ * Content Delivery API. Without a `TBlock` argument, this is the loose
+ * runtime shape (any block, `_editable` optional). With a schema-typed
+ * `TBlock`, fields are narrowed per the block's schema.
+ */
+type BlockContent<TBlock extends Block = Block, TBlocks = NoBlocks> = IsBaseBlock<TBlock> extends true ? BlockContentBase : TBlock extends any ? Prettify<{
+  _uid: string;
+  component: TBlock['name'];
+  _editable?: string;
+} & { [K in RequiredFieldKeys<TBlock['schema']>]: FieldValue<NonNullable<TBlock['schema'][K]>, TBlocks> } & { [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValue<NonNullable<TBlock['schema'][K]>, TBlocks> | null }> : never;
+/** Input variant of {@link BlockContent} for write operations (creating/updating stories via the MAPI). `_uid` is optional. */
+type BlockContentInput<TBlock extends Block = Block, TBlocks = NoBlocks> = IsBaseBlock<TBlock> extends true ? BlockContentInputBase : TBlock extends any ? Prettify<{
+  _uid?: string;
+  component: TBlock['name'];
+  _editable?: string;
+} & { [K in RequiredFieldKeys<TBlock['schema']>]: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> } & { [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> | null }> : never;
+interface FieldTypeValueMap {
+  text: string;
+  textarea: string;
+  richtext: RichtextFieldValue;
+  markdown: string;
+  number: number;
+  datetime: string;
+  boolean: boolean;
+  option: string;
+  options: string[];
+  asset: AssetFieldValue;
+  multiasset: AssetFieldValue[];
+  multilink: MultilinkFieldValue;
+  bloks: BlockContentBase[];
+  table: TableFieldValue;
+  section: never;
+  tab: never;
+  custom: PluginFieldValue;
+}
+type IsNestable<T> = T extends {
+  is_nestable: false;
+} ? false : T extends {
+  is_nestable: true;
+} ? true : true;
+type ApplyWhitelist<TField, TBlocks> = TField extends {
+  component_whitelist: ReadonlyArray<infer TWhitelisted extends string>;
+} ? Extract<TBlocks, {
+  name: TWhitelisted;
+}> : TBlocks extends any ? IsNestable<TBlocks> extends true ? TBlocks : never : never;
+/** Resolves a field definition to its runtime content value type (read). */
+type FieldValue<TField extends Field = Field, TBlocks = NoBlocks> = Prettify<TField extends {
+  type: 'bloks';
+} ? [TBlocks] extends [never] ? BlockContentBase[] : [TBlocks] extends [Block] ? BlockContent<ApplyWhitelist<TField, TBlocks>, TBlocks>[] : BlockContentBase[] : FieldTypeValueMap[TField['type']]>;
+/** Resolves a field definition to its input value type (write). */
+type FieldValueInput<TField extends Field = Field, TBlocks = NoBlocks> = Prettify<TField extends {
+  type: 'bloks';
+} ? [TBlocks] extends [never] ? BlockContentInputBase[] : [TBlocks] extends [Block] ? BlockContentInput<ApplyWhitelist<TField, TBlocks>, TBlocks>[] : BlockContentInputBase[] : FieldTypeValueMap[TField['type']]>;
+//#endregion
+export { BlockContent, BlockContentInput };
+//# sourceMappingURL=field.d.cts.map

package/dist/generated/types/field.d.mts

@@ -0,0 +1,74 @@
+import { AssetFieldValue, BlockContentBase, BlockContentInputBase, Field, MultilinkFieldValue, PluginFieldValue, RichtextFieldValue, TableFieldValue } from "../overlay/_internal.gen.mjs";
+import { Prettify } from "./_utils.mjs";
+import { Block } from "./block.mjs";
+
+//#region src/generated/types/field.d.ts
+/**
+ * Registry of all blocks in the space, used to resolve nested `bloks` fields.
+ * A `Block` union resolves nested content against the registry; `NoBlocks`
+ * (the default) leaves it loose (`BlockContentBase`).
+ */
+type NoBlocks = false;
+/** True when `T` is the un-narrowed base `Block` (i.e. no specific block was supplied). */
+type IsBaseBlock<T> = [Block] extends [T] ? true : false;
+type RequiredFieldKeys<T> = { [K in keyof T]: T[K] extends {
+  required: true;
+} ? K : never }[keyof T];
+type OptionalFieldKeys<T> = Exclude<keyof T, RequiredFieldKeys<T>>;
+/**
+ * Content object for a single block instance as returned by the Storyblok
+ * Content Delivery API. Without a `TBlock` argument, this is the loose
+ * runtime shape (any block, `_editable` optional). With a schema-typed
+ * `TBlock`, fields are narrowed per the block's schema.
+ */
+type BlockContent<TBlock extends Block = Block, TBlocks = NoBlocks> = IsBaseBlock<TBlock> extends true ? BlockContentBase : TBlock extends any ? Prettify<{
+  _uid: string;
+  component: TBlock['name'];
+  _editable?: string;
+} & { [K in RequiredFieldKeys<TBlock['schema']>]: FieldValue<NonNullable<TBlock['schema'][K]>, TBlocks> } & { [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValue<NonNullable<TBlock['schema'][K]>, TBlocks> | null }> : never;
+/** Input variant of {@link BlockContent} for write operations (creating/updating stories via the MAPI). `_uid` is optional. */
+type BlockContentInput<TBlock extends Block = Block, TBlocks = NoBlocks> = IsBaseBlock<TBlock> extends true ? BlockContentInputBase : TBlock extends any ? Prettify<{
+  _uid?: string;
+  component: TBlock['name'];
+  _editable?: string;
+} & { [K in RequiredFieldKeys<TBlock['schema']>]: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> } & { [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> | null }> : never;
+interface FieldTypeValueMap {
+  text: string;
+  textarea: string;
+  richtext: RichtextFieldValue;
+  markdown: string;
+  number: number;
+  datetime: string;
+  boolean: boolean;
+  option: string;
+  options: string[];
+  asset: AssetFieldValue;
+  multiasset: AssetFieldValue[];
+  multilink: MultilinkFieldValue;
+  bloks: BlockContentBase[];
+  table: TableFieldValue;
+  section: never;
+  tab: never;
+  custom: PluginFieldValue;
+}
+type IsNestable<T> = T extends {
+  is_nestable: false;
+} ? false : T extends {
+  is_nestable: true;
+} ? true : true;
+type ApplyWhitelist<TField, TBlocks> = TField extends {
+  component_whitelist: ReadonlyArray<infer TWhitelisted extends string>;
+} ? Extract<TBlocks, {
+  name: TWhitelisted;
+}> : TBlocks extends any ? IsNestable<TBlocks> extends true ? TBlocks : never : never;
+/** Resolves a field definition to its runtime content value type (read). */
+type FieldValue<TField extends Field = Field, TBlocks = NoBlocks> = Prettify<TField extends {
+  type: 'bloks';
+} ? [TBlocks] extends [never] ? BlockContentBase[] : [TBlocks] extends [Block] ? BlockContent<ApplyWhitelist<TField, TBlocks>, TBlocks>[] : BlockContentBase[] : FieldTypeValueMap[TField['type']]>;
+/** Resolves a field definition to its input value type (write). */
+type FieldValueInput<TField extends Field = Field, TBlocks = NoBlocks> = Prettify<TField extends {
+  type: 'bloks';
+} ? [TBlocks] extends [never] ? BlockContentInputBase[] : [TBlocks] extends [Block] ? BlockContentInput<ApplyWhitelist<TField, TBlocks>, TBlocks>[] : BlockContentInputBase[] : FieldTypeValueMap[TField['type']]>;
+//#endregion
+export { BlockContent, BlockContentInput };
+//# sourceMappingURL=field.d.mts.map

package/dist/generated/types/mapi-story.d.cts

@@ -0,0 +1,29 @@
+import { MapiStory as MapiStory$1, StoryCreate as StoryCreate$1, StoryUpdate as StoryUpdate$1 } from "../mapi/_internal.gen.cjs";
+import { Override, Prettify } from "./_utils.cjs";
+import { Block, RootBlock } from "./block.cjs";
+import { BlockContent, BlockContentInput } from "./field.cjs";
+
+//#region src/generated/types/mapi-story.d.ts
+/**
+ * Registry of all blocks, threaded through to resolve nested `bloks` fields.
+ * `NoBlocks` (the default) leaves nested content loose (`BlockContentBase`).
+ */
+type NoBlocks = false;
+/**
+ * Overrides a generated story's `content` with schema-typed block content.
+ * Base (un-narrowed) `RootBlock` means no schema was supplied, so the generated
+ * story passes through unchanged.
+ */
+type MapiStoryWithSchemaContent<TStory extends MapiStory$1 | StoryCreate$1 | StoryUpdate$1, TBlock extends RootBlock = RootBlock, TBlocks = NoBlocks> = RootBlock extends TBlock ? TStory : Override<TStory, {
+  content: TStory extends StoryCreate$1 | StoryUpdate$1 ? BlockContentInput<TBlock, TBlocks> : BlockContent<TBlock, TBlocks>;
+}>;
+type MakeMapiStory<TStory extends MapiStory$1 | StoryCreate$1 | StoryUpdate$1, TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = Prettify<[TBlockOrBlocks] extends [RootBlock] ? MapiStoryWithSchemaContent<TStory, TBlockOrBlocks, TBlocks> : TBlocks extends NoBlocks ? MapiStoryWithSchemaContent<TStory, Extract<TBlockOrBlocks, RootBlock>, TBlockOrBlocks> : never>;
+/** A Storyblok MAPI story. */
+type MapiStory<TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = MakeMapiStory<MapiStory$1, TBlockOrBlocks, TBlocks>;
+/** Payload for creating a story via the MAPI. */
+type StoryCreate<TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = MakeMapiStory<StoryCreate$1, TBlockOrBlocks, TBlocks>;
+/** Payload for updating a story via the MAPI. */
+type StoryUpdate<TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = MakeMapiStory<StoryUpdate$1, TBlockOrBlocks, TBlocks>;
+//#endregion
+export { MapiStory, StoryCreate, StoryUpdate };
+//# sourceMappingURL=mapi-story.d.cts.map

package/dist/generated/types/mapi-story.d.mts

@@ -0,0 +1,29 @@
+import { MapiStory as MapiStory$1, StoryCreate as StoryCreate$1, StoryUpdate as StoryUpdate$1 } from "../mapi/_internal.gen.mjs";
+import { Override, Prettify } from "./_utils.mjs";
+import { Block, RootBlock } from "./block.mjs";
+import { BlockContent, BlockContentInput } from "./field.mjs";
+
+//#region src/generated/types/mapi-story.d.ts
+/**
+ * Registry of all blocks, threaded through to resolve nested `bloks` fields.
+ * `NoBlocks` (the default) leaves nested content loose (`BlockContentBase`).
+ */
+type NoBlocks = false;
+/**
+ * Overrides a generated story's `content` with schema-typed block content.
+ * Base (un-narrowed) `RootBlock` means no schema was supplied, so the generated
+ * story passes through unchanged.
+ */
+type MapiStoryWithSchemaContent<TStory extends MapiStory$1 | StoryCreate$1 | StoryUpdate$1, TBlock extends RootBlock = RootBlock, TBlocks = NoBlocks> = RootBlock extends TBlock ? TStory : Override<TStory, {
+  content: TStory extends StoryCreate$1 | StoryUpdate$1 ? BlockContentInput<TBlock, TBlocks> : BlockContent<TBlock, TBlocks>;
+}>;
+type MakeMapiStory<TStory extends MapiStory$1 | StoryCreate$1 | StoryUpdate$1, TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = Prettify<[TBlockOrBlocks] extends [RootBlock] ? MapiStoryWithSchemaContent<TStory, TBlockOrBlocks, TBlocks> : TBlocks extends NoBlocks ? MapiStoryWithSchemaContent<TStory, Extract<TBlockOrBlocks, RootBlock>, TBlockOrBlocks> : never>;
+/** A Storyblok MAPI story. */
+type MapiStory<TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = MakeMapiStory<MapiStory$1, TBlockOrBlocks, TBlocks>;
+/** Payload for creating a story via the MAPI. */
+type StoryCreate<TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = MakeMapiStory<StoryCreate$1, TBlockOrBlocks, TBlocks>;
+/** Payload for updating a story via the MAPI. */
+type StoryUpdate<TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = MakeMapiStory<StoryUpdate$1, TBlockOrBlocks, TBlocks>;
+//#endregion
+export { MapiStory, StoryCreate, StoryUpdate };
+//# sourceMappingURL=mapi-story.d.mts.map

package/dist/generated/types/story.d.cts

@@ -0,0 +1,19 @@
+import { CapiStory } from "../capi/_internal.gen.cjs";
+import { Override, Prettify } from "./_utils.cjs";
+import { Block, RootBlock } from "./block.cjs";
+import { BlockContent } from "./field.cjs";
+
+//#region src/generated/types/story.d.ts
+/**
+ * Registry of all blocks, threaded through to resolve nested `bloks` fields.
+ * `NoBlocks` (the default) leaves nested content loose (`BlockContentBase`).
+ */
+type NoBlocks = false;
+type CapiStoryWithSchemaContent<TBlock extends RootBlock = RootBlock, TBlocks = NoBlocks> = Override<CapiStory, {
+  content: BlockContent<TBlock, TBlocks>;
+}>;
+/** A Storyblok CDN (CAPI) story. */
+type Story<TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = Prettify<[TBlockOrBlocks] extends [RootBlock] ? CapiStoryWithSchemaContent<TBlockOrBlocks, TBlocks> : TBlocks extends NoBlocks ? CapiStoryWithSchemaContent<Extract<TBlockOrBlocks, RootBlock>, TBlockOrBlocks> : never>;
+//#endregion
+export { Story };
+//# sourceMappingURL=story.d.cts.map

package/dist/generated/types/story.d.mts

@@ -0,0 +1,19 @@
+import { CapiStory } from "../capi/_internal.gen.mjs";
+import { Override, Prettify } from "./_utils.mjs";
+import { Block, RootBlock } from "./block.mjs";
+import { BlockContent } from "./field.mjs";
+
+//#region src/generated/types/story.d.ts
+/**
+ * Registry of all blocks, threaded through to resolve nested `bloks` fields.
+ * `NoBlocks` (the default) leaves nested content loose (`BlockContentBase`).
+ */
+type NoBlocks = false;
+type CapiStoryWithSchemaContent<TBlock extends RootBlock = RootBlock, TBlocks = NoBlocks> = Override<CapiStory, {
+  content: BlockContent<TBlock, TBlocks>;
+}>;
+/** A Storyblok CDN (CAPI) story. */
+type Story<TBlockOrBlocks extends RootBlock | Block = RootBlock, TBlocks = NoBlocks> = Prettify<[TBlockOrBlocks] extends [RootBlock] ? CapiStoryWithSchemaContent<TBlockOrBlocks, TBlocks> : TBlocks extends NoBlocks ? CapiStoryWithSchemaContent<Extract<TBlockOrBlocks, RootBlock>, TBlockOrBlocks> : never>;
+//#endregion
+export { Story };
+//# sourceMappingURL=story.d.mts.map

package/dist/helpers/create-story-helpers.cjs

@@ -0,0 +1,42 @@
+const require_define_story = require('./define-story.cjs');
+
+//#region src/helpers/create-story-helpers.ts
+/**
+* Creates story helper functions pre-bound to your component type union.
+*
+* `withTypes<T>()` accepts either `{ components: ... }` or `{ blocks: ... }` — the
+* latter matches the `Schema` type produced by `InferSchema`, so a project's
+* `Schema` can be passed directly without an extra wrapper.
+*
+* @example
+* ```ts
+* import type { Schema } from './schema';
+*
+* const { defineStory, defineMapiStory, defineStoryCreate, defineStoryUpdate } =
+*   createStoryHelpers().withTypes<Schema>();
+* ```
+*/
+function createStoryHelpers() {
+	return {
+		defineStory: require_define_story.defineStory,
+		defineMapiStory: require_define_story.defineMapiStory,
+		defineStoryCreate: require_define_story.defineStoryCreate,
+		defineStoryUpdate: require_define_story.defineStoryUpdate,
+		withTypes() {
+			const defineStory$1 = (component, story) => require_define_story.defineStory(component, story);
+			const defineMapiStory$1 = (component, story) => require_define_story.defineMapiStory(component, story);
+			const defineStoryCreate$1 = (component, story) => require_define_story.defineStoryCreate(component, story);
+			const defineStoryUpdate$1 = (component, story) => require_define_story.defineStoryUpdate(component, story);
+			return {
+				defineStory: defineStory$1,
+				defineMapiStory: defineMapiStory$1,
+				defineStoryCreate: defineStoryCreate$1,
+				defineStoryUpdate: defineStoryUpdate$1
+			};
+		}
+	};
+}
+
+//#endregion
+exports.createStoryHelpers = createStoryHelpers;
+//# sourceMappingURL=create-story-helpers.cjs.map

package/dist/helpers/create-story-helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-story-helpers.cjs","names":["defineStoryImpl","defineMapiStoryImpl","defineStoryCreateImpl","defineStoryUpdateImpl","defineStory","defineMapiStory","defineStoryCreate","defineStoryUpdate"],"sources":["../../src/helpers/create-story-helpers.ts"],"sourcesContent":["import type { Block, RootBlock } from './define-block';\nimport {\n  defineMapiStory as defineMapiStoryImpl,\n  defineStoryCreate as defineStoryCreateImpl,\n  defineStory as defineStoryImpl,\n  defineStoryUpdate as defineStoryUpdateImpl,\n} from './define-story';\nimport type { MapiStory, Story, StoryCreate, StoryUpdate } from './define-story';\n\ntype StoryblokTypesConfig = { components: Block } | { blocks: Block };\n\ntype ResolveComponents<T extends StoryblokTypesConfig> =\n  T extends { components: infer C extends Block } ? C\n    : T extends { blocks: infer B extends Block } ? B\n      : never;\n\ntype DefineStoryTyped<TBlocks extends Block> =\n  <const TBlock extends RootBlock>(\n    component: TBlock,\n    story: Parameters<typeof defineStoryImpl<TBlock, TBlocks>>[1],\n  ) => Story<TBlock, TBlocks>;\n\ntype DefineMapiStoryTyped<TBlocks extends Block> =\n  <const TBlock extends RootBlock>(\n    component: TBlock,\n    story: Parameters<typeof defineMapiStoryImpl<TBlock, TBlocks>>[1],\n  ) => MapiStory<TBlock, TBlocks>;\n\ntype DefineStoryCreateTyped<TBlocks extends Block> =\n  <const TBlock extends RootBlock>(\n    component: TBlock,\n    story: Parameters<typeof defineStoryCreateImpl<TBlock, TBlocks>>[1],\n  ) => StoryCreate<TBlock, TBlocks>;\n\ntype DefineStoryUpdateTyped<TBlocks extends Block> =\n  <const TBlock extends RootBlock>(\n    component: TBlock,\n    story: Parameters<typeof defineStoryUpdateImpl<TBlock, TBlocks>>[1],\n  ) => StoryUpdate<TBlock, TBlocks>;\n\n/**\n * Creates story helper functions pre-bound to your component type union.\n *\n * `withTypes<T>()` accepts either `{ components: ... }` or `{ blocks: ... }` — the\n * latter matches the `Schema` type produced by `InferSchema`, so a project's\n * `Schema` can be passed directly without an extra wrapper.\n *\n * @example\n * ```ts\n * import type { Schema } from './schema';\n *\n * const { defineStory, defineMapiStory, defineStoryCreate, defineStoryUpdate } =\n *   createStoryHelpers().withTypes<Schema>();\n * ```\n */\nexport function createStoryHelpers() {\n  return {\n    defineStory: defineStoryImpl,\n    defineMapiStory: defineMapiStoryImpl,\n    defineStoryCreate: defineStoryCreateImpl,\n    defineStoryUpdate: defineStoryUpdateImpl,\n    withTypes<T extends StoryblokTypesConfig>() {\n      const defineStory: DefineStoryTyped<ResolveComponents<T>> = (component, story) =>\n        defineStoryImpl(component, story as any);\n\n      const defineMapiStory: DefineMapiStoryTyped<ResolveComponents<T>> = (component, story) =>\n        defineMapiStoryImpl(component, story as any);\n\n      const defineStoryCreate: DefineStoryCreateTyped<ResolveComponents<T>> = (component, story) =>\n        defineStoryCreateImpl(component, story as any);\n\n      const defineStoryUpdate: DefineStoryUpdateTyped<ResolveComponents<T>> = (component, story) =>\n        defineStoryUpdateImpl(component, story as any);\n\n      return { defineStory, defineMapiStory, defineStoryCreate, defineStoryUpdate };\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuDA,SAAgB,qBAAqB;AACnC,QAAO;EACL,aAAaA;EACb,iBAAiBC;EACjB,mBAAmBC;EACnB,mBAAmBC;EACnB,YAA4C;GAC1C,MAAMC,iBAAuD,WAAW,UACtEJ,iCAAgB,WAAW,MAAa;GAE1C,MAAMK,qBAA+D,WAAW,UAC9EJ,qCAAoB,WAAW,MAAa;GAE9C,MAAMK,uBAAmE,WAAW,UAClFJ,uCAAsB,WAAW,MAAa;GAEhD,MAAMK,uBAAmE,WAAW,UAClFJ,uCAAsB,WAAW,MAAa;AAEhD,UAAO;IAAE;IAAa;IAAiB;IAAmB;IAAmB;;EAEhF"}

package/dist/helpers/create-story-helpers.d.cts

@@ -0,0 +1,50 @@
+import { Block, RootBlock } from "../generated/types/block.cjs";
+import { MapiStory, StoryCreate, StoryUpdate } from "../generated/types/mapi-story.cjs";
+import { Story } from "../generated/types/story.cjs";
+import { defineMapiStory, defineStory, defineStoryCreate, defineStoryUpdate } from "./define-story.cjs";
+
+//#region src/helpers/create-story-helpers.d.ts
+type StoryblokTypesConfig = {
+  components: Block;
+} | {
+  blocks: Block;
+};
+type ResolveComponents<T extends StoryblokTypesConfig> = T extends {
+  components: infer C extends Block;
+} ? C : T extends {
+  blocks: infer B extends Block;
+} ? B : never;
+type DefineStoryTyped<TBlocks extends Block> = <const TBlock extends RootBlock>(component: TBlock, story: Parameters<typeof defineStory<TBlock, TBlocks>>[1]) => Story<TBlock, TBlocks>;
+type DefineMapiStoryTyped<TBlocks extends Block> = <const TBlock extends RootBlock>(component: TBlock, story: Parameters<typeof defineMapiStory<TBlock, TBlocks>>[1]) => MapiStory<TBlock, TBlocks>;
+type DefineStoryCreateTyped<TBlocks extends Block> = <const TBlock extends RootBlock>(component: TBlock, story: Parameters<typeof defineStoryCreate<TBlock, TBlocks>>[1]) => StoryCreate<TBlock, TBlocks>;
+type DefineStoryUpdateTyped<TBlocks extends Block> = <const TBlock extends RootBlock>(component: TBlock, story: Parameters<typeof defineStoryUpdate<TBlock, TBlocks>>[1]) => StoryUpdate<TBlock, TBlocks>;
+/**
+ * Creates story helper functions pre-bound to your component type union.
+ *
+ * `withTypes<T>()` accepts either `{ components: ... }` or `{ blocks: ... }` — the
+ * latter matches the `Schema` type produced by `InferSchema`, so a project's
+ * `Schema` can be passed directly without an extra wrapper.
+ *
+ * @example
+ * ```ts
+ * import type { Schema } from './schema';
+ *
+ * const { defineStory, defineMapiStory, defineStoryCreate, defineStoryUpdate } =
+ *   createStoryHelpers().withTypes<Schema>();
+ * ```
+ */
+declare function createStoryHelpers(): {
+  defineStory: typeof defineStory;
+  defineMapiStory: typeof defineMapiStory;
+  defineStoryCreate: typeof defineStoryCreate;
+  defineStoryUpdate: typeof defineStoryUpdate;
+  withTypes<T extends StoryblokTypesConfig>(): {
+    defineStory: DefineStoryTyped<ResolveComponents<T>>;
+    defineMapiStory: DefineMapiStoryTyped<ResolveComponents<T>>;
+    defineStoryCreate: DefineStoryCreateTyped<ResolveComponents<T>>;
+    defineStoryUpdate: DefineStoryUpdateTyped<ResolveComponents<T>>;
+  };
+};
+//#endregion
+export { createStoryHelpers };
+//# sourceMappingURL=create-story-helpers.d.cts.map

package/dist/helpers/create-story-helpers.d.mts

@@ -0,0 +1,50 @@
+import { Block, RootBlock } from "../generated/types/block.mjs";
+import { MapiStory, StoryCreate, StoryUpdate } from "../generated/types/mapi-story.mjs";
+import { Story } from "../generated/types/story.mjs";
+import { defineMapiStory, defineStory, defineStoryCreate, defineStoryUpdate } from "./define-story.mjs";
+
+//#region src/helpers/create-story-helpers.d.ts
+type StoryblokTypesConfig = {
+  components: Block;
+} | {
+  blocks: Block;
+};
+type ResolveComponents<T extends StoryblokTypesConfig> = T extends {
+  components: infer C extends Block;
+} ? C : T extends {
+  blocks: infer B extends Block;
+} ? B : never;
+type DefineStoryTyped<TBlocks extends Block> = <const TBlock extends RootBlock>(component: TBlock, story: Parameters<typeof defineStory<TBlock, TBlocks>>[1]) => Story<TBlock, TBlocks>;
+type DefineMapiStoryTyped<TBlocks extends Block> = <const TBlock extends RootBlock>(component: TBlock, story: Parameters<typeof defineMapiStory<TBlock, TBlocks>>[1]) => MapiStory<TBlock, TBlocks>;
+type DefineStoryCreateTyped<TBlocks extends Block> = <const TBlock extends RootBlock>(component: TBlock, story: Parameters<typeof defineStoryCreate<TBlock, TBlocks>>[1]) => StoryCreate<TBlock, TBlocks>;
+type DefineStoryUpdateTyped<TBlocks extends Block> = <const TBlock extends RootBlock>(component: TBlock, story: Parameters<typeof defineStoryUpdate<TBlock, TBlocks>>[1]) => StoryUpdate<TBlock, TBlocks>;
+/**
+ * Creates story helper functions pre-bound to your component type union.
+ *
+ * `withTypes<T>()` accepts either `{ components: ... }` or `{ blocks: ... }` — the
+ * latter matches the `Schema` type produced by `InferSchema`, so a project's
+ * `Schema` can be passed directly without an extra wrapper.
+ *
+ * @example
+ * ```ts
+ * import type { Schema } from './schema';
+ *
+ * const { defineStory, defineMapiStory, defineStoryCreate, defineStoryUpdate } =
+ *   createStoryHelpers().withTypes<Schema>();
+ * ```
+ */
+declare function createStoryHelpers(): {
+  defineStory: typeof defineStory;
+  defineMapiStory: typeof defineMapiStory;
+  defineStoryCreate: typeof defineStoryCreate;
+  defineStoryUpdate: typeof defineStoryUpdate;
+  withTypes<T extends StoryblokTypesConfig>(): {
+    defineStory: DefineStoryTyped<ResolveComponents<T>>;
+    defineMapiStory: DefineMapiStoryTyped<ResolveComponents<T>>;
+    defineStoryCreate: DefineStoryCreateTyped<ResolveComponents<T>>;
+    defineStoryUpdate: DefineStoryUpdateTyped<ResolveComponents<T>>;
+  };
+};
+//#endregion
+export { createStoryHelpers };
+//# sourceMappingURL=create-story-helpers.d.mts.map

package/dist/helpers/create-story-helpers.mjs

@@ -0,0 +1,42 @@
+import { defineMapiStory, defineStory, defineStoryCreate, defineStoryUpdate } from "./define-story.mjs";
+
+//#region src/helpers/create-story-helpers.ts
+/**
+* Creates story helper functions pre-bound to your component type union.
+*
+* `withTypes<T>()` accepts either `{ components: ... }` or `{ blocks: ... }` — the
+* latter matches the `Schema` type produced by `InferSchema`, so a project's
+* `Schema` can be passed directly without an extra wrapper.
+*
+* @example
+* ```ts
+* import type { Schema } from './schema';
+*
+* const { defineStory, defineMapiStory, defineStoryCreate, defineStoryUpdate } =
+*   createStoryHelpers().withTypes<Schema>();
+* ```
+*/
+function createStoryHelpers() {
+	return {
+		defineStory,
+		defineMapiStory,
+		defineStoryCreate,
+		defineStoryUpdate,
+		withTypes() {
+			const defineStory$1 = (component, story) => defineStory(component, story);
+			const defineMapiStory$1 = (component, story) => defineMapiStory(component, story);
+			const defineStoryCreate$1 = (component, story) => defineStoryCreate(component, story);
+			const defineStoryUpdate$1 = (component, story) => defineStoryUpdate(component, story);
+			return {
+				defineStory: defineStory$1,
+				defineMapiStory: defineMapiStory$1,
+				defineStoryCreate: defineStoryCreate$1,
+				defineStoryUpdate: defineStoryUpdate$1
+			};
+		}
+	};
+}
+
+//#endregion
+export { createStoryHelpers };
+//# sourceMappingURL=create-story-helpers.mjs.map

package/dist/helpers/create-story-helpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-story-helpers.mjs","names":["defineStoryImpl","defineMapiStoryImpl","defineStoryCreateImpl","defineStoryUpdateImpl","defineStory","defineMapiStory","defineStoryCreate","defineStoryUpdate"],"sources":["../../src/helpers/create-story-helpers.ts"],"sourcesContent":["import type { Block, RootBlock } from './define-block';\nimport {\n  defineMapiStory as defineMapiStoryImpl,\n  defineStoryCreate as defineStoryCreateImpl,\n  defineStory as defineStoryImpl,\n  defineStoryUpdate as defineStoryUpdateImpl,\n} from './define-story';\nimport type { MapiStory, Story, StoryCreate, StoryUpdate } from './define-story';\n\ntype StoryblokTypesConfig = { components: Block } | { blocks: Block };\n\ntype ResolveComponents<T extends StoryblokTypesConfig> =\n  T extends { components: infer C extends Block } ? C\n    : T extends { blocks: infer B extends Block } ? B\n      : never;\n\ntype DefineStoryTyped<TBlocks extends Block> =\n  <const TBlock extends RootBlock>(\n    component: TBlock,\n    story: Parameters<typeof defineStoryImpl<TBlock, TBlocks>>[1],\n  ) => Story<TBlock, TBlocks>;\n\ntype DefineMapiStoryTyped<TBlocks extends Block> =\n  <const TBlock extends RootBlock>(\n    component: TBlock,\n    story: Parameters<typeof defineMapiStoryImpl<TBlock, TBlocks>>[1],\n  ) => MapiStory<TBlock, TBlocks>;\n\ntype DefineStoryCreateTyped<TBlocks extends Block> =\n  <const TBlock extends RootBlock>(\n    component: TBlock,\n    story: Parameters<typeof defineStoryCreateImpl<TBlock, TBlocks>>[1],\n  ) => StoryCreate<TBlock, TBlocks>;\n\ntype DefineStoryUpdateTyped<TBlocks extends Block> =\n  <const TBlock extends RootBlock>(\n    component: TBlock,\n    story: Parameters<typeof defineStoryUpdateImpl<TBlock, TBlocks>>[1],\n  ) => StoryUpdate<TBlock, TBlocks>;\n\n/**\n * Creates story helper functions pre-bound to your component type union.\n *\n * `withTypes<T>()` accepts either `{ components: ... }` or `{ blocks: ... }` — the\n * latter matches the `Schema` type produced by `InferSchema`, so a project's\n * `Schema` can be passed directly without an extra wrapper.\n *\n * @example\n * ```ts\n * import type { Schema } from './schema';\n *\n * const { defineStory, defineMapiStory, defineStoryCreate, defineStoryUpdate } =\n *   createStoryHelpers().withTypes<Schema>();\n * ```\n */\nexport function createStoryHelpers() {\n  return {\n    defineStory: defineStoryImpl,\n    defineMapiStory: defineMapiStoryImpl,\n    defineStoryCreate: defineStoryCreateImpl,\n    defineStoryUpdate: defineStoryUpdateImpl,\n    withTypes<T extends StoryblokTypesConfig>() {\n      const defineStory: DefineStoryTyped<ResolveComponents<T>> = (component, story) =>\n        defineStoryImpl(component, story as any);\n\n      const defineMapiStory: DefineMapiStoryTyped<ResolveComponents<T>> = (component, story) =>\n        defineMapiStoryImpl(component, story as any);\n\n      const defineStoryCreate: DefineStoryCreateTyped<ResolveComponents<T>> = (component, story) =>\n        defineStoryCreateImpl(component, story as any);\n\n      const defineStoryUpdate: DefineStoryUpdateTyped<ResolveComponents<T>> = (component, story) =>\n        defineStoryUpdateImpl(component, story as any);\n\n      return { defineStory, defineMapiStory, defineStoryCreate, defineStoryUpdate };\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuDA,SAAgB,qBAAqB;AACnC,QAAO;EACQA;EACIC;EACEC;EACAC;EACnB,YAA4C;GAC1C,MAAMC,iBAAuD,WAAW,UACtEJ,YAAgB,WAAW,MAAa;GAE1C,MAAMK,qBAA+D,WAAW,UAC9EJ,gBAAoB,WAAW,MAAa;GAE9C,MAAMK,uBAAmE,WAAW,UAClFJ,kBAAsB,WAAW,MAAa;GAEhD,MAAMK,uBAAmE,WAAW,UAClFJ,kBAAsB,WAAW,MAAa;AAEhD,UAAO;IAAE;IAAa;IAAiB;IAAmB;IAAmB;;EAEhF"}

package/dist/helpers/define-asset-folder.cjs

@@ -0,0 +1,46 @@
+
+//#region src/helpers/define-asset-folder.ts
+const ASSET_FOLDER_DEFAULTS = {
+	id: 1,
+	parent_id: null,
+	parent_uuid: null
+};
+/**
+* Defines an asset folder.
+* When `uuid` is not provided, it defaults to the folder name
+* (prefixed by `parent_uuid/` for nested folders).
+*
+* @example
+* const folder = defineAssetFolder({ name: 'Images' });
+* // folder.uuid === 'Images'
+*/
+const defineAssetFolder = (assetFolder) => {
+	const uuid = assetFolder.uuid || (assetFolder.parent_uuid ? `${assetFolder.parent_uuid}/${assetFolder.name}` : assetFolder.name);
+	return {
+		...ASSET_FOLDER_DEFAULTS,
+		...assetFolder,
+		parent_id: assetFolder.parent_id ?? ASSET_FOLDER_DEFAULTS.parent_id,
+		parent_uuid: assetFolder.parent_uuid ?? ASSET_FOLDER_DEFAULTS.parent_uuid,
+		uuid
+	};
+};
+/**
+* Defines an asset folder creation payload.
+*
+* @example
+* const payload = defineAssetFolderCreate({ name: 'Images' });
+*/
+const defineAssetFolderCreate = (assetFolder) => assetFolder;
+/**
+* Defines an asset folder update payload.
+*
+* @example
+* const payload = defineAssetFolderUpdate({ name: 'Updated Images' });
+*/
+const defineAssetFolderUpdate = (assetFolder) => assetFolder;
+
+//#endregion
+exports.defineAssetFolder = defineAssetFolder;
+exports.defineAssetFolderCreate = defineAssetFolderCreate;
+exports.defineAssetFolderUpdate = defineAssetFolderUpdate;
+//# sourceMappingURL=define-asset-folder.cjs.map

package/dist/helpers/define-asset-folder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-asset-folder.cjs","names":[],"sources":["../../src/helpers/define-asset-folder.ts"],"sourcesContent":["import type { AssetFolder, AssetFolderCreate, AssetFolderUpdate } from '../generated/mapi/types.gen';\n\nconst ASSET_FOLDER_DEFAULTS = {\n  id: 1,\n  parent_id: null,\n  parent_uuid: null,\n};\n\nexport type { AssetFolder, AssetFolderCreate, AssetFolderUpdate };\n\ntype AssetFolderInput = { name: string } & Partial<Omit<AssetFolder, 'name'>>;\n\n/**\n * Defines an asset folder.\n * When `uuid` is not provided, it defaults to the folder name\n * (prefixed by `parent_uuid/` for nested folders).\n *\n * @example\n * const folder = defineAssetFolder({ name: 'Images' });\n * // folder.uuid === 'Images'\n */\nexport const defineAssetFolder = (assetFolder: AssetFolderInput): AssetFolder => {\n  const uuid = assetFolder.uuid\n    || (assetFolder.parent_uuid ? `${assetFolder.parent_uuid}/${assetFolder.name}` : assetFolder.name);\n\n  return {\n    ...ASSET_FOLDER_DEFAULTS,\n    ...assetFolder,\n    parent_id: assetFolder.parent_id ?? ASSET_FOLDER_DEFAULTS.parent_id,\n    parent_uuid: assetFolder.parent_uuid ?? ASSET_FOLDER_DEFAULTS.parent_uuid,\n    uuid,\n  };\n};\n\n/**\n * Defines an asset folder creation payload.\n *\n * @example\n * const payload = defineAssetFolderCreate({ name: 'Images' });\n */\nexport const defineAssetFolderCreate = (assetFolder: AssetFolderCreate): AssetFolderCreate => assetFolder;\n\n/**\n * Defines an asset folder update payload.\n *\n * @example\n * const payload = defineAssetFolderUpdate({ name: 'Updated Images' });\n */\nexport const defineAssetFolderUpdate = (assetFolder: AssetFolderUpdate): AssetFolderUpdate => assetFolder;\n"],"mappings":";;AAEA,MAAM,wBAAwB;CAC5B,IAAI;CACJ,WAAW;CACX,aAAa;CACd;;;;;;;;;;AAeD,MAAa,qBAAqB,gBAA+C;CAC/E,MAAM,OAAO,YAAY,SACnB,YAAY,cAAc,GAAG,YAAY,YAAY,GAAG,YAAY,SAAS,YAAY;AAE/F,QAAO;EACL,GAAG;EACH,GAAG;EACH,WAAW,YAAY,aAAa,sBAAsB;EAC1D,aAAa,YAAY,eAAe,sBAAsB;EAC9D;EACD;;;;;;;;AASH,MAAa,2BAA2B,gBAAsD;;;;;;;AAQ9F,MAAa,2BAA2B,gBAAsD"}