@storyblok/schema 0.1.0-alpha.0 → 0.1.0-alpha.1

package/dist/helpers/define-datasource.mjs

@@ -11,21 +11,7 @@ function defineDatasource(datasource) {
 		...datasource
 	};
 }
-/**
-* Defines a datasource creation payload for the MAPI.
-*
-* @example
-* const payload = defineDatasourceCreate({ name: 'Colors', slug: 'colors' });
-*/
-const defineDatasourceCreate = (datasource) => datasource;
-/**
-* Defines a datasource update payload for the MAPI.
-*
-* @example
-* const payload = defineDatasourceUpdate({ name: 'Updated Colors' });
-*/
-const defineDatasourceUpdate = (datasource) => datasource;
 
 //#endregion
-export { defineDatasource, defineDatasourceCreate, defineDatasourceUpdate };
+export { defineDatasource };
 //# sourceMappingURL=define-datasource.mjs.map

package/dist/helpers/define-datasource.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"define-datasource.mjs","names":[],"sources":["../../src/helpers/define-datasource.ts"],"sourcesContent":["import type { Datasource } from '../generated/capi/types.gen';\nimport type { DatasourceCreate, DatasourceUpdate } from '../generated/mapi/types.gen';\nimport type { Prettify } from '../utils/prettify';\n\nconst DATASOURCE_DEFAULTS = {\n  id: 1,\n  created_at: '',\n  updated_at: '',\n  dimensions: [],\n};\n\nexport type { Datasource, DatasourceCreate, DatasourceUpdate };\n\n/** Fields that have safe defaults and may be omitted from datasource input. */\ntype DatasourceOptional = keyof typeof DATASOURCE_DEFAULTS;\n\ntype DatasourceInput = Prettify<Omit<Datasource, DatasourceOptional> & Partial<Pick<Datasource, DatasourceOptional>>>;\n\n/**\n * Returns a full {@link Datasource} with all fields populated. API-assigned\n * fields are optional and default to safe values.\n *\n * @example\n * const myDatasource = defineDatasource({\n *   name: 'Colors',\n *   slug: 'colors',\n * });\n */\n// Overload: provides the strict public signature for callers.\nexport function defineDatasource(datasource: DatasourceInput): Datasource;\n\n// Implementation signature: uses a loose parameter type because\n// TypeScript requires the implementation signature to be assignable\n// to all overloads. Not visible to callers.\nexport function defineDatasource(datasource: any) {\n  return { ...DATASOURCE_DEFAULTS, ...datasource };\n}\n\n/**\n * Defines a datasource creation payload for the MAPI.\n *\n * @example\n * const payload = defineDatasourceCreate({ name: 'Colors', slug: 'colors' });\n */\nexport const defineDatasourceCreate = (datasource: DatasourceCreate): DatasourceCreate => datasource;\n\n/**\n * Defines a datasource update payload for the MAPI.\n *\n * @example\n * const payload = defineDatasourceUpdate({ name: 'Updated Colors' });\n */\nexport const defineDatasourceUpdate = (datasource: DatasourceUpdate): DatasourceUpdate => datasource;\n"],"mappings":";AAIA,MAAM,sBAAsB;CAC1B,IAAI;CACJ,YAAY;CACZ,YAAY;CACZ,YAAY,EAAE;CACf;AAyBD,SAAgB,iBAAiB,YAAiB;AAChD,QAAO;EAAE,GAAG;EAAqB,GAAG;EAAY;;;;;;;;AASlD,MAAa,0BAA0B,eAAmD;;;;;;;AAQ1F,MAAa,0BAA0B,eAAmD"}
+{"version":3,"file":"define-datasource.mjs","names":[],"sources":["../../src/helpers/define-datasource.ts"],"sourcesContent":["import type { Datasource as DatasourceGenerated } from '../generated/capi/types.gen';\nimport type { Override } from '../generated/types/_utils';\nimport type { Prettify } from '../utils/prettify';\n\nconst DATASOURCE_DEFAULTS = {\n  id: 1,\n  created_at: '',\n  updated_at: '',\n  dimensions: [],\n};\n\n/**\n * A Storyblok datasource content shape. Carries the datasource definition only\n * (`name`, `slug`, dimensions). Entry values are content authored by editors,\n * not part of the schema, so they are neither modelled nor pushed here.\n */\nexport type Datasource = Override<DatasourceGenerated, { slug: string }>;\n\n/** Fields that have safe defaults and may be omitted from datasource input. */\ntype DatasourceOptional = keyof typeof DATASOURCE_DEFAULTS;\n\ntype DatasourceInput = Prettify<Omit<Datasource, DatasourceOptional> & Partial<Pick<Datasource, DatasourceOptional>>>;\n\n/**\n * Returns a {@link Datasource} content-shape definition. A thin, strongly-typed\n * helper — it does not validate or throw.\n *\n * @example\n * const colors = defineDatasource({ name: 'Colors', slug: 'colors' });\n */\nexport function defineDatasource(datasource: DatasourceInput): Datasource;\nexport function defineDatasource(datasource: any) {\n  return { ...DATASOURCE_DEFAULTS, ...datasource };\n}\n"],"mappings":";AAIA,MAAM,sBAAsB;CAC1B,IAAI;CACJ,YAAY;CACZ,YAAY;CACZ,YAAY,EAAE;CACf;AAsBD,SAAgB,iBAAiB,YAAiB;AAChD,QAAO;EAAE,GAAG;EAAqB,GAAG;EAAY"}

package/dist/helpers/define-field.cjs

@@ -1,16 +1,16 @@
+const require_is_record = require('../utils/is-record.cjs');
 
 //#region src/helpers/define-field.ts
-/**
-* Returns a {@link Field} stamped with the given `name`. Use inside a
-* {@link defineBlock} `schema` array — `pos` is inferred from array index.
-*
-* @example
-* defineField('headline', { type: 'text', max_length: 100, required: true });
-*/
-const defineField = (name, field) => ({
-	...field,
-	name
-});
+function defineField(name, field) {
+	const { allow, datasource, ...rest } = field;
+	const normalized = {
+		...rest,
+		name
+	};
+	if (allow !== void 0) normalized.allow = (Array.isArray(allow) ? allow : [allow]).map((ref) => typeof ref === "string" ? ref : require_is_record.isRecord(ref) ? ref.name : void 0);
+	if (datasource !== void 0) normalized.datasource = typeof datasource === "string" ? datasource : require_is_record.isRecord(datasource) ? datasource.slug : void 0;
+	return normalized;
+}
 
 //#endregion
 exports.defineField = defineField;

package/dist/helpers/define-field.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"define-field.cjs","names":[],"sources":["../../src/helpers/define-field.ts"],"sourcesContent":["import type {\n  AssetFieldValue,\n  Field,\n  MultilinkFieldValue,\n  PluginFieldValue,\n  RichtextFieldValue,\n  TableFieldValue,\n} from '../generated/types/field';\nimport type { Block } from './define-block';\nimport type { Prettify } from '../utils/prettify';\n\nexport type { Field };\n\n/** Loose variant of the generated `BlokContent` with `_uid` optional — used as the fallback for write operations when no block union is provided. */\ntype BlokContentLoose = {\n  _uid?: string;\n  component: string;\n  _editable?: string | undefined;\n} & {\n  [key: string]:\n    | string\n    | number\n    | boolean\n    | Array<string | AssetFieldValue | BlokContentLoose>\n    | AssetFieldValue\n    | MultilinkFieldValue\n    | TableFieldValue\n    | RichtextFieldValue\n    | PluginFieldValue\n    | undefined;\n};\n\n/** Keys in a schema record that have `required: true`. */\ntype RequiredFieldKeys<T> = {\n  [K in keyof T]: T[K] extends { required: true } ? K : never\n}[keyof T];\n\n/** Keys in a schema record that do NOT have `required: true`. */\ntype OptionalFieldKeys<T> = Exclude<keyof T, RequiredFieldKeys<T>>;\n\n/**\n * Builds the content object for a single block instance as returned by the\n * Storyblok Content Delivery API. Includes `_uid` (always present in API\n * responses) and respects required/optional field semantics.\n *\n * For write operations (creating/updating stories), use {@link BlockContentInput}\n * instead, which omits `_uid` since Storyblok generates it automatically.\n */\nexport type BlockContent<TBlock extends Block = Block, TBlocks = false> = TBlock extends any\n  ? { _uid: string; component: TBlock['name'] }\n  & {\n    [K in RequiredFieldKeys<TBlock['schema']>]: FieldValue<NonNullable<TBlock['schema'][K]>, TBlocks>\n  }\n  & {\n    [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValue<NonNullable<TBlock['schema'][K]>, TBlocks> | null\n  }\n  : never;\n\n/**\n * Input variant of {@link BlockContent} for write operations (creating/updating\n * stories via the MAPI). `_uid` is optional — Storyblok generates it\n * automatically when omitted. Nested bloks fields also use this input variant\n * so that deeply nested blocks do not require `_uid` either.\n */\nexport type BlockContentInput<TBlock extends Block = Block, TBlocks = false> = TBlock extends any\n  ? { _uid?: string; component: TBlock['name'] }\n  & {\n    [K in RequiredFieldKeys<TBlock['schema']>]: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks>\n  }\n  & {\n    [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> | null\n  }\n  : never;\n\nexport type BlocksFieldValue<\n  TBlock extends Block = Block,\n  TBlocks = false,\n> = BlockContent<TBlock, TBlocks>[];\n\nexport type { AssetFieldValue, MultilinkFieldValue, PluginFieldValue, RichtextFieldValue, TableFieldValue };\n\n/** Union of all valid Storyblok field type discriminants (e.g., `text`, `bloks`). */\nexport type FieldType = Field['type'];\n\n/** Maps each field type discriminant to its runtime content value type. */\ninterface FieldTypeValueMap {\n  text: string;\n  textarea: string;\n  richtext: RichtextFieldValue;\n  markdown: string;\n  number: number;\n  datetime: string;\n  boolean: boolean;\n  option: string;\n  options: string[];\n  asset: AssetFieldValue;\n  multiasset: AssetFieldValue[];\n  multilink: MultilinkFieldValue;\n  bloks: BlockContent[];\n  table: TableFieldValue;\n  section: never;\n  tab: never;\n  custom: PluginFieldValue;\n}\n\n/**\n * Checks whether a block is nestable, defaulting to `true` when\n * `is_nestable` is absent or undefined.\n */\ntype IsNestable<T> =\n  T extends { is_nestable: false } ? false\n    : T extends { is_nestable: true } ? true\n      : true; // default: nestable when is_nestable is not specified\n\ntype ApplyWhitelist<TField, TBlocks> = TField extends { component_whitelist: ReadonlyArray<infer TWhitelisted extends string> }\n  // With whitelist: filter by block name (distributive over TBlocks)\n  ? TBlocks extends { name: TWhitelisted } ? TBlocks : never\n  // No whitelist: filter by nestability (distributive over TBlocks)\n  : TBlocks extends any\n    ? IsNestable<TBlocks> extends true ? TBlocks : never\n    : never;\n\n/** Resolves a field definition to its runtime content value type (read). */\nexport type FieldValue<\n  TField extends Field = Field,\n  TBlocks = false,\n> = Prettify<\n  TField extends { type: 'bloks' }\n    // Bloks field — guard against `never` first (it satisfies `[never] extends [X]`\n    // for all X, which would incorrectly enter the typed path with empty results).\n    ? [TBlocks] extends [never]\n        ? BlockContent[]\n        : [TBlocks] extends [Block]\n            ? BlockContent<ApplyWhitelist<TField, TBlocks>, TBlocks>[]\n            : BlockContent[]\n    // No bloks field\n    : FieldTypeValueMap[TField['type']]\n>;\n\n/** Resolves a field definition to its input value type (write). Nested bloks use {@link BlockContentInput}. */\nexport type FieldValueInput<\n  TField extends Field = Field,\n  TBlocks = false,\n> = Prettify<\n  TField extends { type: 'bloks' }\n    ? [TBlocks] extends [never]\n        ? BlokContentLoose[]\n        : [TBlocks] extends [Block]\n            ? BlockContentInput<ApplyWhitelist<TField, TBlocks>, TBlocks>[]\n            : BlokContentLoose[]\n    : FieldTypeValueMap[TField['type']]\n>;\n\n/**\n * Returns a {@link Field} stamped with the given `name`. Use inside a\n * {@link defineBlock} `schema` array — `pos` is inferred from array index.\n *\n * @example\n * defineField('headline', { type: 'text', max_length: 100, required: true });\n */\nexport const defineField = <\n  const TName extends string,\n  const TField extends Field,\n>(\n  name: TName,\n  field: TField,\n): Omit<TField, 'name'> & { name: TName } => ({ ...field, name });\n"],"mappings":";;;;;;;;;AAgKA,MAAa,eAIX,MACA,WAC4C;CAAE,GAAG;CAAO;CAAM"}
+{"version":3,"file":"define-field.cjs","names":["isRecord"],"sources":["../../src/helpers/define-field.ts"],"sourcesContent":["import type {\n  AssetFieldValue,\n  BlockContent,\n  BlockContentInput,\n  BlocksFieldValue,\n  Field,\n  FieldType,\n  FieldValue,\n  FieldValueInput,\n  MultilinkFieldValue,\n  PluginFieldValue,\n  RichtextFieldValue,\n  TableFieldValue,\n} from '../generated/types/field';\nimport type { Prettify } from '../utils/prettify';\nimport { isRecord } from '../utils/is-record';\n\nexport type {\n  AssetFieldValue,\n  BlockContent,\n  BlockContentInput,\n  BlocksFieldValue,\n  Field,\n  FieldType,\n  FieldValue,\n  FieldValueInput,\n  MultilinkFieldValue,\n  PluginFieldValue,\n  RichtextFieldValue,\n  TableFieldValue,\n};\n\n/** A block reference for `allow`: a defined block object or its name. */\ntype AllowRef = string | { name: string };\n/** A datasource reference for `datasource`: a defined datasource object or its slug. */\ntype DatasourceRef = string | { slug: string };\n\ntype NameOf<T> = T extends string ? T : T extends { name: infer N extends string } ? N : never;\ntype SlugOf<T> = T extends string ? T : T extends { slug: infer S extends string } ? S : never;\n\n/** Normalizes an `allow` input (ref, name, or array thereof) to a tuple of block-name strings. */\ntype NormalizeAllow<T> = T extends readonly any[]\n  ? { [I in keyof T]: NameOf<T[I]> }\n  : readonly [NameOf<T>];\n\n/**\n * Field config accepted by {@link defineField}: the content-shape field plus the\n * DSL reference keys. `allow` replaces the wire `component_whitelist`; `datasource`\n * holds the datasource ref/slug (the wire `source` selector still passes through).\n */\nexport type FieldInput = Field & {\n  allow?: AllowRef | readonly AllowRef[];\n  datasource?: DatasourceRef;\n  required?: boolean;\n};\n\n/** Result of {@link defineField}: the field stamped with `name`, with refs normalized to strings. */\nexport type DefinedField<TName extends string, TField extends FieldInput> = Prettify<\n  Omit<TField, 'allow' | 'datasource' | 'name'>\n  & { name: TName }\n  & (TField extends { allow: infer A } ? { allow: NormalizeAllow<A> } : unknown)\n  & (TField extends { datasource: infer D } ? { datasource: SlugOf<D> } : unknown)\n>;\n\n/**\n * Returns a {@link Field} stamped with the given `name`, normalizing reference\n * keys to strings so everything downstream sees plain names/slugs. A thin,\n * strongly-typed identity helper — it does not validate or throw.\n *\n * Use inside a {@link defineBlock} `fields` array — `pos` is injected from the\n * array index by `defineBlock`.\n *\n * @example\n * defineField('headline', { type: 'text', max_length: 100, required: true });\n * defineField('body', { type: 'bloks', allow: [heroBlock, 'teaser'] });\n * defineField('theme', { type: 'option', source: 'internal', datasource: colors });\n */\nexport function defineField<\n  const TName extends string,\n  const TField extends FieldInput,\n>(name: TName, field: TField): DefinedField<TName, TField>;\nexport function defineField(name: string, field: Record<string, unknown>): Record<string, unknown> {\n  const { allow, datasource, ...rest } = field;\n  const normalized: Record<string, unknown> = { ...rest, name };\n  if (allow !== undefined) {\n    const refs = Array.isArray(allow) ? allow : [allow];\n    normalized.allow = refs.map(ref => (typeof ref === 'string' ? ref : isRecord(ref) ? ref.name : undefined));\n  }\n  if (datasource !== undefined) {\n    normalized.datasource = typeof datasource === 'string' ? datasource : isRecord(datasource) ? datasource.slug : undefined;\n  }\n  return normalized;\n}\n"],"mappings":";;;AAiFA,SAAgB,YAAY,MAAc,OAAyD;CACjG,MAAM,EAAE,OAAO,YAAY,GAAG,SAAS;CACvC,MAAM,aAAsC;EAAE,GAAG;EAAM;EAAM;AAC7D,KAAI,UAAU,OAEZ,YAAW,SADE,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM,EAC3B,KAAI,QAAQ,OAAO,QAAQ,WAAW,MAAMA,2BAAS,IAAI,GAAG,IAAI,OAAO,OAAW;AAE5G,KAAI,eAAe,OACjB,YAAW,aAAa,OAAO,eAAe,WAAW,aAAaA,2BAAS,WAAW,GAAG,WAAW,OAAO;AAEjH,QAAO"}

package/dist/helpers/define-field.d.cts

@@ -1,99 +1,60 @@
 import { AssetFieldValue, Field, MultilinkFieldValue, PluginFieldValue, RichtextFieldValue, TableFieldValue } from "../generated/overlay/_internal.gen.cjs";
-import { Block } from "../generated/types/block.cjs";
+import { BlockContent, BlockContentInput, BlocksFieldValue, FieldType, FieldValue, FieldValueInput } from "../generated/types/field.cjs";
 import { Prettify } from "../utils/prettify.cjs";
 
 //#region src/helpers/define-field.d.ts
-/** Loose variant of the generated `BlokContent` with `_uid` optional — used as the fallback for write operations when no block union is provided. */
-type BlokContentLoose = {
-  _uid?: string;
-  component: string;
-  _editable?: string | undefined;
-} & {
-  [key: string]: string | number | boolean | Array<string | AssetFieldValue | BlokContentLoose> | AssetFieldValue | MultilinkFieldValue | TableFieldValue | RichtextFieldValue | PluginFieldValue | undefined;
+/** A block reference for `allow`: a defined block object or its name. */
+type AllowRef = string | {
+  name: string;
 };
-/** Keys in a schema record that have `required: true`. */
-type RequiredFieldKeys<T> = { [K in keyof T]: T[K] extends {
-  required: true;
-} ? K : never }[keyof T];
-/** Keys in a schema record that do NOT have `required: true`. */
-type OptionalFieldKeys<T> = Exclude<keyof T, RequiredFieldKeys<T>>;
-/**
- * Builds the content object for a single block instance as returned by the
- * Storyblok Content Delivery API. Includes `_uid` (always present in API
- * responses) and respects required/optional field semantics.
- *
- * For write operations (creating/updating stories), use {@link BlockContentInput}
- * instead, which omits `_uid` since Storyblok generates it automatically.
- */
-type BlockContent<TBlock extends Block = Block, TBlocks = false> = TBlock extends any ? {
-  _uid: string;
-  component: TBlock['name'];
-} & { [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 — Storyblok generates it
- * automatically when omitted. Nested bloks fields also use this input variant
- * so that deeply nested blocks do not require `_uid` either.
- */
-type BlockContentInput<TBlock extends Block = Block, TBlocks = false> = TBlock extends any ? {
-  _uid?: string;
-  component: TBlock['name'];
-} & { [K in RequiredFieldKeys<TBlock['schema']>]: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> } & { [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> | null } : never;
-type BlocksFieldValue<TBlock extends Block = Block, TBlocks = false> = BlockContent<TBlock, TBlocks>[];
-/** Union of all valid Storyblok field type discriminants (e.g., `text`, `bloks`). */
-type FieldType = Field['type'];
-/** Maps each field type discriminant to its runtime content value type. */
-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: BlockContent[];
-  table: TableFieldValue;
-  section: never;
-  tab: never;
-  custom: PluginFieldValue;
-}
+/** A datasource reference for `datasource`: a defined datasource object or its slug. */
+type DatasourceRef = string | {
+  slug: string;
+};
+type NameOf<T> = T extends string ? T : T extends {
+  name: infer N extends string;
+} ? N : never;
+type SlugOf<T> = T extends string ? T : T extends {
+  slug: infer S extends string;
+} ? S : never;
+/** Normalizes an `allow` input (ref, name, or array thereof) to a tuple of block-name strings. */
+type NormalizeAllow<T> = T extends readonly any[] ? { [I in keyof T]: NameOf<T[I]> } : readonly [NameOf<T>];
 /**
- * Checks whether a block is nestable, defaulting to `true` when
- * `is_nestable` is absent or undefined.
+ * Field config accepted by {@link defineField}: the content-shape field plus the
+ * DSL reference keys. `allow` replaces the wire `component_whitelist`; `datasource`
+ * holds the datasource ref/slug (the wire `source` selector still passes through).
  */
-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>;
-} ? TBlocks extends {
-  name: TWhitelisted;
-} ? TBlocks : never : 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 = false> = Prettify<TField extends {
-  type: 'bloks';
-} ? [TBlocks] extends [never] ? BlockContent[] : [TBlocks] extends [Block] ? BlockContent<ApplyWhitelist<TField, TBlocks>, TBlocks>[] : BlockContent[] : FieldTypeValueMap[TField['type']]>;
-/** Resolves a field definition to its input value type (write). Nested bloks use {@link BlockContentInput}. */
-type FieldValueInput<TField extends Field = Field, TBlocks = false> = Prettify<TField extends {
-  type: 'bloks';
-} ? [TBlocks] extends [never] ? BlokContentLoose[] : [TBlocks] extends [Block] ? BlockContentInput<ApplyWhitelist<TField, TBlocks>, TBlocks>[] : BlokContentLoose[] : FieldTypeValueMap[TField['type']]>;
+type FieldInput = Field & {
+  allow?: AllowRef | readonly AllowRef[];
+  datasource?: DatasourceRef;
+  required?: boolean;
+};
+/** Result of {@link defineField}: the field stamped with `name`, with refs normalized to strings. */
+type DefinedField<TName extends string, TField extends FieldInput> = Prettify<Omit<TField, 'allow' | 'datasource' | 'name'> & {
+  name: TName;
+} & (TField extends {
+  allow: infer A;
+} ? {
+  allow: NormalizeAllow<A>;
+} : unknown) & (TField extends {
+  datasource: infer D;
+} ? {
+  datasource: SlugOf<D>;
+} : unknown)>;
 /**
- * Returns a {@link Field} stamped with the given `name`. Use inside a
- * {@link defineBlock} `schema` array — `pos` is inferred from array index.
+ * Returns a {@link Field} stamped with the given `name`, normalizing reference
+ * keys to strings so everything downstream sees plain names/slugs. A thin,
+ * strongly-typed identity helper — it does not validate or throw.
+ *
+ * Use inside a {@link defineBlock} `fields` array — `pos` is injected from the
+ * array index by `defineBlock`.
  *
  * @example
  * defineField('headline', { type: 'text', max_length: 100, required: true });
+ * defineField('body', { type: 'bloks', allow: [heroBlock, 'teaser'] });
+ * defineField('theme', { type: 'option', source: 'internal', datasource: colors });
  */
-declare const defineField: <const TName extends string, const TField extends Field>(name: TName, field: TField) => Omit<TField, "name"> & {
-  name: TName;
-};
+declare function defineField<const TName extends string, const TField extends FieldInput>(name: TName, field: TField): DefinedField<TName, TField>;
 //#endregion
-export { BlockContent, BlockContentInput, BlocksFieldValue, FieldType, FieldValue, FieldValueInput, defineField };
+export { DefinedField, FieldInput, defineField };
 //# sourceMappingURL=define-field.d.cts.map

package/dist/helpers/define-field.d.mts

@@ -1,99 +1,60 @@
 import { AssetFieldValue, Field, MultilinkFieldValue, PluginFieldValue, RichtextFieldValue, TableFieldValue } from "../generated/overlay/_internal.gen.mjs";
-import { Block } from "../generated/types/block.mjs";
+import { BlockContent, BlockContentInput, BlocksFieldValue, FieldType, FieldValue, FieldValueInput } from "../generated/types/field.mjs";
 import { Prettify } from "../utils/prettify.mjs";
 
 //#region src/helpers/define-field.d.ts
-/** Loose variant of the generated `BlokContent` with `_uid` optional — used as the fallback for write operations when no block union is provided. */
-type BlokContentLoose = {
-  _uid?: string;
-  component: string;
-  _editable?: string | undefined;
-} & {
-  [key: string]: string | number | boolean | Array<string | AssetFieldValue | BlokContentLoose> | AssetFieldValue | MultilinkFieldValue | TableFieldValue | RichtextFieldValue | PluginFieldValue | undefined;
+/** A block reference for `allow`: a defined block object or its name. */
+type AllowRef = string | {
+  name: string;
 };
-/** Keys in a schema record that have `required: true`. */
-type RequiredFieldKeys<T> = { [K in keyof T]: T[K] extends {
-  required: true;
-} ? K : never }[keyof T];
-/** Keys in a schema record that do NOT have `required: true`. */
-type OptionalFieldKeys<T> = Exclude<keyof T, RequiredFieldKeys<T>>;
-/**
- * Builds the content object for a single block instance as returned by the
- * Storyblok Content Delivery API. Includes `_uid` (always present in API
- * responses) and respects required/optional field semantics.
- *
- * For write operations (creating/updating stories), use {@link BlockContentInput}
- * instead, which omits `_uid` since Storyblok generates it automatically.
- */
-type BlockContent<TBlock extends Block = Block, TBlocks = false> = TBlock extends any ? {
-  _uid: string;
-  component: TBlock['name'];
-} & { [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 — Storyblok generates it
- * automatically when omitted. Nested bloks fields also use this input variant
- * so that deeply nested blocks do not require `_uid` either.
- */
-type BlockContentInput<TBlock extends Block = Block, TBlocks = false> = TBlock extends any ? {
-  _uid?: string;
-  component: TBlock['name'];
-} & { [K in RequiredFieldKeys<TBlock['schema']>]: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> } & { [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> | null } : never;
-type BlocksFieldValue<TBlock extends Block = Block, TBlocks = false> = BlockContent<TBlock, TBlocks>[];
-/** Union of all valid Storyblok field type discriminants (e.g., `text`, `bloks`). */
-type FieldType = Field['type'];
-/** Maps each field type discriminant to its runtime content value type. */
-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: BlockContent[];
-  table: TableFieldValue;
-  section: never;
-  tab: never;
-  custom: PluginFieldValue;
-}
+/** A datasource reference for `datasource`: a defined datasource object or its slug. */
+type DatasourceRef = string | {
+  slug: string;
+};
+type NameOf<T> = T extends string ? T : T extends {
+  name: infer N extends string;
+} ? N : never;
+type SlugOf<T> = T extends string ? T : T extends {
+  slug: infer S extends string;
+} ? S : never;
+/** Normalizes an `allow` input (ref, name, or array thereof) to a tuple of block-name strings. */
+type NormalizeAllow<T> = T extends readonly any[] ? { [I in keyof T]: NameOf<T[I]> } : readonly [NameOf<T>];
 /**
- * Checks whether a block is nestable, defaulting to `true` when
- * `is_nestable` is absent or undefined.
+ * Field config accepted by {@link defineField}: the content-shape field plus the
+ * DSL reference keys. `allow` replaces the wire `component_whitelist`; `datasource`
+ * holds the datasource ref/slug (the wire `source` selector still passes through).
  */
-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>;
-} ? TBlocks extends {
-  name: TWhitelisted;
-} ? TBlocks : never : 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 = false> = Prettify<TField extends {
-  type: 'bloks';
-} ? [TBlocks] extends [never] ? BlockContent[] : [TBlocks] extends [Block] ? BlockContent<ApplyWhitelist<TField, TBlocks>, TBlocks>[] : BlockContent[] : FieldTypeValueMap[TField['type']]>;
-/** Resolves a field definition to its input value type (write). Nested bloks use {@link BlockContentInput}. */
-type FieldValueInput<TField extends Field = Field, TBlocks = false> = Prettify<TField extends {
-  type: 'bloks';
-} ? [TBlocks] extends [never] ? BlokContentLoose[] : [TBlocks] extends [Block] ? BlockContentInput<ApplyWhitelist<TField, TBlocks>, TBlocks>[] : BlokContentLoose[] : FieldTypeValueMap[TField['type']]>;
+type FieldInput = Field & {
+  allow?: AllowRef | readonly AllowRef[];
+  datasource?: DatasourceRef;
+  required?: boolean;
+};
+/** Result of {@link defineField}: the field stamped with `name`, with refs normalized to strings. */
+type DefinedField<TName extends string, TField extends FieldInput> = Prettify<Omit<TField, 'allow' | 'datasource' | 'name'> & {
+  name: TName;
+} & (TField extends {
+  allow: infer A;
+} ? {
+  allow: NormalizeAllow<A>;
+} : unknown) & (TField extends {
+  datasource: infer D;
+} ? {
+  datasource: SlugOf<D>;
+} : unknown)>;
 /**
- * Returns a {@link Field} stamped with the given `name`. Use inside a
- * {@link defineBlock} `schema` array — `pos` is inferred from array index.
+ * Returns a {@link Field} stamped with the given `name`, normalizing reference
+ * keys to strings so everything downstream sees plain names/slugs. A thin,
+ * strongly-typed identity helper — it does not validate or throw.
+ *
+ * Use inside a {@link defineBlock} `fields` array — `pos` is injected from the
+ * array index by `defineBlock`.
  *
  * @example
  * defineField('headline', { type: 'text', max_length: 100, required: true });
+ * defineField('body', { type: 'bloks', allow: [heroBlock, 'teaser'] });
+ * defineField('theme', { type: 'option', source: 'internal', datasource: colors });
  */
-declare const defineField: <const TName extends string, const TField extends Field>(name: TName, field: TField) => Omit<TField, "name"> & {
-  name: TName;
-};
+declare function defineField<const TName extends string, const TField extends FieldInput>(name: TName, field: TField): DefinedField<TName, TField>;
 //#endregion
-export { BlockContent, BlockContentInput, BlocksFieldValue, FieldType, FieldValue, FieldValueInput, defineField };
+export { DefinedField, FieldInput, defineField };
 //# sourceMappingURL=define-field.d.mts.map

package/dist/helpers/define-field.mjs

@@ -1,15 +1,16 @@
+import { isRecord } from "../utils/is-record.mjs";
+
 //#region src/helpers/define-field.ts
-/**
-* Returns a {@link Field} stamped with the given `name`. Use inside a
-* {@link defineBlock} `schema` array — `pos` is inferred from array index.
-*
-* @example
-* defineField('headline', { type: 'text', max_length: 100, required: true });
-*/
-const defineField = (name, field) => ({
-	...field,
-	name
-});
+function defineField(name, field) {
+	const { allow, datasource, ...rest } = field;
+	const normalized = {
+		...rest,
+		name
+	};
+	if (allow !== void 0) normalized.allow = (Array.isArray(allow) ? allow : [allow]).map((ref) => typeof ref === "string" ? ref : isRecord(ref) ? ref.name : void 0);
+	if (datasource !== void 0) normalized.datasource = typeof datasource === "string" ? datasource : isRecord(datasource) ? datasource.slug : void 0;
+	return normalized;
+}
 
 //#endregion
 export { defineField };

package/dist/helpers/define-field.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"define-field.mjs","names":[],"sources":["../../src/helpers/define-field.ts"],"sourcesContent":["import type {\n  AssetFieldValue,\n  Field,\n  MultilinkFieldValue,\n  PluginFieldValue,\n  RichtextFieldValue,\n  TableFieldValue,\n} from '../generated/types/field';\nimport type { Block } from './define-block';\nimport type { Prettify } from '../utils/prettify';\n\nexport type { Field };\n\n/** Loose variant of the generated `BlokContent` with `_uid` optional — used as the fallback for write operations when no block union is provided. */\ntype BlokContentLoose = {\n  _uid?: string;\n  component: string;\n  _editable?: string | undefined;\n} & {\n  [key: string]:\n    | string\n    | number\n    | boolean\n    | Array<string | AssetFieldValue | BlokContentLoose>\n    | AssetFieldValue\n    | MultilinkFieldValue\n    | TableFieldValue\n    | RichtextFieldValue\n    | PluginFieldValue\n    | undefined;\n};\n\n/** Keys in a schema record that have `required: true`. */\ntype RequiredFieldKeys<T> = {\n  [K in keyof T]: T[K] extends { required: true } ? K : never\n}[keyof T];\n\n/** Keys in a schema record that do NOT have `required: true`. */\ntype OptionalFieldKeys<T> = Exclude<keyof T, RequiredFieldKeys<T>>;\n\n/**\n * Builds the content object for a single block instance as returned by the\n * Storyblok Content Delivery API. Includes `_uid` (always present in API\n * responses) and respects required/optional field semantics.\n *\n * For write operations (creating/updating stories), use {@link BlockContentInput}\n * instead, which omits `_uid` since Storyblok generates it automatically.\n */\nexport type BlockContent<TBlock extends Block = Block, TBlocks = false> = TBlock extends any\n  ? { _uid: string; component: TBlock['name'] }\n  & {\n    [K in RequiredFieldKeys<TBlock['schema']>]: FieldValue<NonNullable<TBlock['schema'][K]>, TBlocks>\n  }\n  & {\n    [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValue<NonNullable<TBlock['schema'][K]>, TBlocks> | null\n  }\n  : never;\n\n/**\n * Input variant of {@link BlockContent} for write operations (creating/updating\n * stories via the MAPI). `_uid` is optional — Storyblok generates it\n * automatically when omitted. Nested bloks fields also use this input variant\n * so that deeply nested blocks do not require `_uid` either.\n */\nexport type BlockContentInput<TBlock extends Block = Block, TBlocks = false> = TBlock extends any\n  ? { _uid?: string; component: TBlock['name'] }\n  & {\n    [K in RequiredFieldKeys<TBlock['schema']>]: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks>\n  }\n  & {\n    [K in OptionalFieldKeys<TBlock['schema']>]?: FieldValueInput<NonNullable<TBlock['schema'][K]>, TBlocks> | null\n  }\n  : never;\n\nexport type BlocksFieldValue<\n  TBlock extends Block = Block,\n  TBlocks = false,\n> = BlockContent<TBlock, TBlocks>[];\n\nexport type { AssetFieldValue, MultilinkFieldValue, PluginFieldValue, RichtextFieldValue, TableFieldValue };\n\n/** Union of all valid Storyblok field type discriminants (e.g., `text`, `bloks`). */\nexport type FieldType = Field['type'];\n\n/** Maps each field type discriminant to its runtime content value type. */\ninterface FieldTypeValueMap {\n  text: string;\n  textarea: string;\n  richtext: RichtextFieldValue;\n  markdown: string;\n  number: number;\n  datetime: string;\n  boolean: boolean;\n  option: string;\n  options: string[];\n  asset: AssetFieldValue;\n  multiasset: AssetFieldValue[];\n  multilink: MultilinkFieldValue;\n  bloks: BlockContent[];\n  table: TableFieldValue;\n  section: never;\n  tab: never;\n  custom: PluginFieldValue;\n}\n\n/**\n * Checks whether a block is nestable, defaulting to `true` when\n * `is_nestable` is absent or undefined.\n */\ntype IsNestable<T> =\n  T extends { is_nestable: false } ? false\n    : T extends { is_nestable: true } ? true\n      : true; // default: nestable when is_nestable is not specified\n\ntype ApplyWhitelist<TField, TBlocks> = TField extends { component_whitelist: ReadonlyArray<infer TWhitelisted extends string> }\n  // With whitelist: filter by block name (distributive over TBlocks)\n  ? TBlocks extends { name: TWhitelisted } ? TBlocks : never\n  // No whitelist: filter by nestability (distributive over TBlocks)\n  : TBlocks extends any\n    ? IsNestable<TBlocks> extends true ? TBlocks : never\n    : never;\n\n/** Resolves a field definition to its runtime content value type (read). */\nexport type FieldValue<\n  TField extends Field = Field,\n  TBlocks = false,\n> = Prettify<\n  TField extends { type: 'bloks' }\n    // Bloks field — guard against `never` first (it satisfies `[never] extends [X]`\n    // for all X, which would incorrectly enter the typed path with empty results).\n    ? [TBlocks] extends [never]\n        ? BlockContent[]\n        : [TBlocks] extends [Block]\n            ? BlockContent<ApplyWhitelist<TField, TBlocks>, TBlocks>[]\n            : BlockContent[]\n    // No bloks field\n    : FieldTypeValueMap[TField['type']]\n>;\n\n/** Resolves a field definition to its input value type (write). Nested bloks use {@link BlockContentInput}. */\nexport type FieldValueInput<\n  TField extends Field = Field,\n  TBlocks = false,\n> = Prettify<\n  TField extends { type: 'bloks' }\n    ? [TBlocks] extends [never]\n        ? BlokContentLoose[]\n        : [TBlocks] extends [Block]\n            ? BlockContentInput<ApplyWhitelist<TField, TBlocks>, TBlocks>[]\n            : BlokContentLoose[]\n    : FieldTypeValueMap[TField['type']]\n>;\n\n/**\n * Returns a {@link Field} stamped with the given `name`. Use inside a\n * {@link defineBlock} `schema` array — `pos` is inferred from array index.\n *\n * @example\n * defineField('headline', { type: 'text', max_length: 100, required: true });\n */\nexport const defineField = <\n  const TName extends string,\n  const TField extends Field,\n>(\n  name: TName,\n  field: TField,\n): Omit<TField, 'name'> & { name: TName } => ({ ...field, name });\n"],"mappings":";;;;;;;;AAgKA,MAAa,eAIX,MACA,WAC4C;CAAE,GAAG;CAAO;CAAM"}
+{"version":3,"file":"define-field.mjs","names":[],"sources":["../../src/helpers/define-field.ts"],"sourcesContent":["import type {\n  AssetFieldValue,\n  BlockContent,\n  BlockContentInput,\n  BlocksFieldValue,\n  Field,\n  FieldType,\n  FieldValue,\n  FieldValueInput,\n  MultilinkFieldValue,\n  PluginFieldValue,\n  RichtextFieldValue,\n  TableFieldValue,\n} from '../generated/types/field';\nimport type { Prettify } from '../utils/prettify';\nimport { isRecord } from '../utils/is-record';\n\nexport type {\n  AssetFieldValue,\n  BlockContent,\n  BlockContentInput,\n  BlocksFieldValue,\n  Field,\n  FieldType,\n  FieldValue,\n  FieldValueInput,\n  MultilinkFieldValue,\n  PluginFieldValue,\n  RichtextFieldValue,\n  TableFieldValue,\n};\n\n/** A block reference for `allow`: a defined block object or its name. */\ntype AllowRef = string | { name: string };\n/** A datasource reference for `datasource`: a defined datasource object or its slug. */\ntype DatasourceRef = string | { slug: string };\n\ntype NameOf<T> = T extends string ? T : T extends { name: infer N extends string } ? N : never;\ntype SlugOf<T> = T extends string ? T : T extends { slug: infer S extends string } ? S : never;\n\n/** Normalizes an `allow` input (ref, name, or array thereof) to a tuple of block-name strings. */\ntype NormalizeAllow<T> = T extends readonly any[]\n  ? { [I in keyof T]: NameOf<T[I]> }\n  : readonly [NameOf<T>];\n\n/**\n * Field config accepted by {@link defineField}: the content-shape field plus the\n * DSL reference keys. `allow` replaces the wire `component_whitelist`; `datasource`\n * holds the datasource ref/slug (the wire `source` selector still passes through).\n */\nexport type FieldInput = Field & {\n  allow?: AllowRef | readonly AllowRef[];\n  datasource?: DatasourceRef;\n  required?: boolean;\n};\n\n/** Result of {@link defineField}: the field stamped with `name`, with refs normalized to strings. */\nexport type DefinedField<TName extends string, TField extends FieldInput> = Prettify<\n  Omit<TField, 'allow' | 'datasource' | 'name'>\n  & { name: TName }\n  & (TField extends { allow: infer A } ? { allow: NormalizeAllow<A> } : unknown)\n  & (TField extends { datasource: infer D } ? { datasource: SlugOf<D> } : unknown)\n>;\n\n/**\n * Returns a {@link Field} stamped with the given `name`, normalizing reference\n * keys to strings so everything downstream sees plain names/slugs. A thin,\n * strongly-typed identity helper — it does not validate or throw.\n *\n * Use inside a {@link defineBlock} `fields` array — `pos` is injected from the\n * array index by `defineBlock`.\n *\n * @example\n * defineField('headline', { type: 'text', max_length: 100, required: true });\n * defineField('body', { type: 'bloks', allow: [heroBlock, 'teaser'] });\n * defineField('theme', { type: 'option', source: 'internal', datasource: colors });\n */\nexport function defineField<\n  const TName extends string,\n  const TField extends FieldInput,\n>(name: TName, field: TField): DefinedField<TName, TField>;\nexport function defineField(name: string, field: Record<string, unknown>): Record<string, unknown> {\n  const { allow, datasource, ...rest } = field;\n  const normalized: Record<string, unknown> = { ...rest, name };\n  if (allow !== undefined) {\n    const refs = Array.isArray(allow) ? allow : [allow];\n    normalized.allow = refs.map(ref => (typeof ref === 'string' ? ref : isRecord(ref) ? ref.name : undefined));\n  }\n  if (datasource !== undefined) {\n    normalized.datasource = typeof datasource === 'string' ? datasource : isRecord(datasource) ? datasource.slug : undefined;\n  }\n  return normalized;\n}\n"],"mappings":";;;AAiFA,SAAgB,YAAY,MAAc,OAAyD;CACjG,MAAM,EAAE,OAAO,YAAY,GAAG,SAAS;CACvC,MAAM,aAAsC;EAAE,GAAG;EAAM;EAAM;AAC7D,KAAI,UAAU,OAEZ,YAAW,SADE,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM,EAC3B,KAAI,QAAQ,OAAO,QAAQ,WAAW,MAAM,SAAS,IAAI,GAAG,IAAI,OAAO,OAAW;AAE5G,KAAI,eAAe,OACjB,YAAW,aAAa,OAAO,eAAe,WAAW,aAAa,SAAS,WAAW,GAAG,WAAW,OAAO;AAEjH,QAAO"}

package/dist/helpers/schema-type.d.cts

@@ -1,14 +1,14 @@
 import { Block } from "../generated/types/block.cjs";
-import { Datasource } from "../generated/capi/types.gen.cjs";
-import { ComponentFolder } from "../generated/mapi/types.gen.cjs";
+import { Datasource } from "./define-datasource.cjs";
 
 //#region src/helpers/schema-type.d.ts
 /**
  * Derives a schema types interface from a schema object.
  *
- * Accepts the `typeof` a schema object whose `blocks` property is a
- * record of `defineBlock()` results, and optionally `blockFolders`
- * and `datasources` records, and produces a type with unions of those types.
+ * Accepts the `typeof` a schema object whose `blocks` property is a record of
+ * `defineBlock()` results, and optionally a `datasources` record, and produces
+ * a type with unions of those types. A schema describes content shapes only;
+ * component groups are a UI concern and not part of it.
  *
  * @example
  * ```ts
@@ -16,23 +16,19 @@ import { ComponentFolder } from "../generated/mapi/types.gen.cjs";
  *
  * export const schema = {
  *   blocks: { pageBlock, heroBlock },
- *   blockFolders: { layoutFolder },
  *   datasources: { colorsDatasource },
  * };
  *
  * export type Schema = InferSchema<typeof schema>;
  * export type Blocks = Schema['blocks'];
- * export type BlockFolders = Schema['blockFolders'];
  * export type Datasources = Schema['datasources'];
  * ```
  */
 interface Schema<T extends {
   blocks: Record<string, Block>;
-  blockFolders?: Record<string, ComponentFolder>;
   datasources?: Record<string, Datasource>;
 }> {
   blocks: T['blocks'][keyof T['blocks']];
-  blockFolders: T['blockFolders'] extends Record<string, ComponentFolder> ? T['blockFolders'][keyof T['blockFolders']] : never;
   datasources: T['datasources'] extends Record<string, Datasource> ? T['datasources'][keyof T['datasources']] : never;
 }
 //#endregion

package/dist/helpers/schema-type.d.mts

@@ -1,14 +1,14 @@
 import { Block } from "../generated/types/block.mjs";
-import { Datasource } from "../generated/capi/types.gen.mjs";
-import { ComponentFolder } from "../generated/mapi/types.gen.mjs";
+import { Datasource } from "./define-datasource.mjs";
 
 //#region src/helpers/schema-type.d.ts
 /**
  * Derives a schema types interface from a schema object.
  *
- * Accepts the `typeof` a schema object whose `blocks` property is a
- * record of `defineBlock()` results, and optionally `blockFolders`
- * and `datasources` records, and produces a type with unions of those types.
+ * Accepts the `typeof` a schema object whose `blocks` property is a record of
+ * `defineBlock()` results, and optionally a `datasources` record, and produces
+ * a type with unions of those types. A schema describes content shapes only;
+ * component groups are a UI concern and not part of it.
  *
  * @example
  * ```ts
@@ -16,23 +16,19 @@ import { ComponentFolder } from "../generated/mapi/types.gen.mjs";
  *
  * export const schema = {
  *   blocks: { pageBlock, heroBlock },
- *   blockFolders: { layoutFolder },
  *   datasources: { colorsDatasource },
  * };
  *
  * export type Schema = InferSchema<typeof schema>;
  * export type Blocks = Schema['blocks'];
- * export type BlockFolders = Schema['blockFolders'];
  * export type Datasources = Schema['datasources'];
  * ```
  */
 interface Schema<T extends {
   blocks: Record<string, Block>;
-  blockFolders?: Record<string, ComponentFolder>;
   datasources?: Record<string, Datasource>;
 }> {
   blocks: T['blocks'][keyof T['blocks']];
-  blockFolders: T['blockFolders'] extends Record<string, ComponentFolder> ? T['blockFolders'][keyof T['blockFolders']] : never;
   datasources: T['datasources'] extends Record<string, Datasource> ? T['datasources'][keyof T['datasources']] : never;
 }
 //#endregion