import { Component } from "../mapi/types-aliased.gen.cjs";
import { Field } from "../overlay/_internal.gen.cjs";
import { Override } from "./_utils.cjs";
//#region src/generated/types/block.d.ts
/**
 * Ordered array of named fields — the content-shape DSL form `defineBlock`
 * accepts and returns. A field's position in the array sets the order it appears
 * in the editor (mapped to the wire `pos` on push).
 */
type BlockFields = ReadonlyArray<Field & {
  name: string;
  pos?: number;
  required?: boolean;
}>;
/**
 * A Storyblok block: a named, ordered set of content fields. Uses the
 * content-shape DSL `fields` array rather than the MAPI wire `schema` record.
 */
type Block<TName extends string = string, TFields extends BlockFields = BlockFields, TIsRoot extends boolean = boolean, TIsNestable extends boolean = boolean> = Override<Omit<Component, "schema" | "component_group_uuid">, {
  name: TName;
  fields: TFields;
  is_root?: TIsRoot;
  is_nestable?: TIsNestable;
  /**
   * Escape hatch for pinning this block to a Storyblok UI-managed component
   * group by UUID. Component groups are normally maintained in code via the
   * schema directory layout; set this only if you intentionally manage groups
   * in the Storyblok UI, and fill in the group UUID yourself. When set,
   * `schema push` diffs it and sends it to the Management API; when omitted,
   * the block's remote group is left untouched.
   *
   * @deprecated Prefer maintaining component groups in code through the
   * directory layout.
   */
  component_group_uuid?: string | null;
  /**
   * Folder membership as a display name path (e.g. `'Layout/Heros'`); `null` =
   * explicitly ungrouped (push clears the group). Absent = unmanaged (push
   * leaves the remote group untouched).
   */
  folder?: string | null;
  /**
   * Block tags by name (e.g. `['Marketing']`). Names are resolved to the
   * target space's tag ids at push time, and a tag the space does not have yet
   * is created, so the same schema pushes to any space.
   */
  tags?: readonly string[];
  /**
   * Escape hatch for tagging this block by raw id. Tag ids are space-local, so
   * a schema carrying them only pushes to the space it was read from; use
   * `tags` to name the tags instead.
   *
   * @deprecated Prefer `tags`, which names the tags and is portable across
   * spaces.
   */
  internal_tag_ids?: string[];
}>;
/**
 * 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;
}>;
//#endregion
export { Block, BlockFields, RootBlock };
//# sourceMappingURL=block.d.cts.map