@blokkli/editor 2.0.0-alpha.36 → 2.0.0-alpha.38

package/dist/modules/charts/runtime/blokkli/skills/charts.js

@@ -2,27 +2,27 @@ import { defineBlokkliAgentSkill } from "#blokkli/agent/server/skills";
 export default defineBlokkliAgentSkill({
   name: "charts",
   label: { en: "Working with charts", de: "Arbeiten mit Diagrammen" },
-  description: "How charts work in bl\xF6kkli. LOAD THIS when the user asks about charts or when you need to create or update a chart! Charts are a special blokkli_fragment.",
+  description: "How charts work in bl\xF6kkli. LOAD THIS when the user asks about charts or when you need to create or update a chart!",
   getContents: () => `
 # Charts
 
-Charts are implemented as **fragments** with the bundle "blokkli_fragment" and the fragment name "blokkli_chart". When you see a paragraph with bundle "blokkli_fragment" and fragmentName "blokkli_chart", that IS the chart paragraph.
+Charts are NOT a specific block bundle. Instead, charts are a **complex option type**: any block can have a JSON option with \`dataType: 'chart'\`. The chart data is stored as a JSON string in that option. The option key can be anything (e.g. "data", "chart", etc.) \u2014 the tools detect it automatically.
 
 ## Key concept
 
-The chart paragraph's UUID is what you pass directly to the chart tools. There is no separate "chart entity" inside the fragment \u2014 the fragment IS the chart.
+A "chart block" is any block whose definition has a JSON option with \`dataType: 'chart'\`. The chart tools automatically detect which option holds chart data, so you don't need to know the option key or bundle name.
 
 ## Available tools
 
 - **get_chart_data**: Read the current chart data (type, categories, series, colors, typeOptions). Always call this first when modifying an existing chart!
-- **create_chart**: Create a new chart. Requires chart data (type, categories, series).
-- **update_chart**: Update an existing chart. Pass the fragment paragraph's UUID and only the properties you want to change (title, type, categories, series, categoryColors, footnotes, typeOptions).
+- **create_chart**: Create a new chart. Requires chart data (type, categories, series). The tool automatically finds which bundle in the target field has a chart option.
+- **update_chart**: Update an existing chart. Pass the block's UUID and only the properties you want to change (title, type, categories, series, categoryColors, footnotes, typeOptions).
 - **get_chart_type_options**: Get available typeOptions for a chart type. Call this to discover which rendering options exist (e.g. stacked, horizontal for bar charts) before setting typeOptions.
 
 ## Workflow
 
 1. To **read** a chart's current state: use get_chart_data with the paragraph UUID.
-2. To **create** a chart: use create_chart with the data.
+2. To **create** a chart: use create_chart with the data. The tool finds the right bundle automatically from the target field's allowed bundles.
 3. To **modify** a chart: first call get_chart_data to see the current state, then use update_chart with only the properties you want to change.
 4. To **change rendering options** (e.g. stacked bars, smooth lines, grid lines): first call get_chart_type_options with the chart type to see available options, then use update_chart with the typeOptions property.
 

package/dist/modules/charts/runtime/blokkli/tools/chart_schemas.d.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import type { BlokkliChartData, ChartColor } from '#blokkli/charts/types';
+import type { McpToolContext } from '#blokkli/agent/app/types';
 export declare const chartTypeEnum: z.ZodEnum<{
     bar: "bar";
     line: "line";
-    pie: "pie";
     area: "area";
+    pie: "pie";
     donut: "donut";
     heatmap: "heatmap";
     radialBar: "radialBar";
@@ -25,8 +26,8 @@ export declare const chartDataSchema: z.ZodObject<{
     type: z.ZodEnum<{
         bar: "bar";
         line: "line";
-        pie: "pie";
         area: "area";
+        pie: "pie";
         donut: "donut";
         heatmap: "heatmap";
         radialBar: "radialBar";
@@ -61,3 +62,25 @@ export declare function validateChartData(data: BlokkliChartData, colors: Record
 } | {
     data: BlokkliChartData;
 };
+/**
+ * Find the option key for a chart option on a block.
+ *
+ * Charts are stored as a JSON option with `dataType: 'chart'` on any block.
+ * This helper looks up the block's definition and returns the option key.
+ */
+export declare function findChartOptionKey(ctx: McpToolContext, uuid: string): {
+    key: string;
+} | {
+    error: string;
+};
+/**
+ * Find a bundle that has a chart option among a field's allowed bundles.
+ *
+ * Returns the bundle name and the option key for the chart data.
+ */
+export declare function findChartBundle(ctx: McpToolContext, allowedBundles: string[]): {
+    bundle: string;
+    key: string;
+} | {
+    error: string;
+};

package/dist/modules/charts/runtime/blokkli/tools/chart_schemas.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { getColorIdAtIndex } from "#blokkli/charts/types";
+import { getColorIdAtIndex } from "../../helpers/index.js";
 import { getChartTypeRuntime, getDefaultTypeOptions } from "../../chartTypes/index.js";
 import { COLORS } from "#blokkli-build/charts-config";
 const SINGLE_SERIES_TYPES = ["pie", "donut", "radialBar"];
@@ -96,3 +96,41 @@ export function validateChartData(data, colors) {
   }
   return { data };
 }
+export function findChartOptionKey(ctx, uuid) {
+  const { blocks, definitions, selection } = ctx.app;
+  const block = blocks.getBlock(uuid);
+  if (!block) return { error: `Paragraph not found: ${uuid}` };
+  const bundle = block.library?.reusableBundle || block.bundle;
+  const selectionItem = selection.items.value.find((v) => v.uuid === uuid);
+  const definition = definitions.getBlockDefinition(
+    bundle,
+    selectionItem?.fieldListType ?? "default",
+    selectionItem?.parentBlockBundle
+  );
+  if (!definition?.options) {
+    return { error: `Paragraph "${uuid}" (${bundle}) has no chart option.` };
+  }
+  const chartEntry = Object.entries(definition.options).find(
+    ([_, opt]) => opt.type === "json" && "dataType" in opt && opt.dataType === "chart"
+  );
+  if (!chartEntry) {
+    return { error: `Paragraph "${uuid}" (${bundle}) has no chart option.` };
+  }
+  return { key: chartEntry[0] };
+}
+export function findChartBundle(ctx, allowedBundles) {
+  const { definitions } = ctx.app;
+  for (const bundle of allowedBundles) {
+    const def = definitions.getDefaultDefinition(bundle);
+    if (!def?.options) continue;
+    const entry = Object.entries(def.options).find(
+      ([_, opt]) => opt.type === "json" && "dataType" in opt && opt.dataType === "chart"
+    );
+    if (entry) {
+      return { bundle, key: entry[0] };
+    }
+  }
+  return {
+    error: `No block type with a chart option is allowed in this field.`
+  };
+}

package/dist/modules/charts/runtime/blokkli/tools/create_chart/index.js

@@ -3,10 +3,14 @@ import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import {
   mutationResultSchema,
   parentSchema,
-  positionSchema,
-  resolvePosition
+  positionSchema
 } from "#blokkli/agent/app/tools/schemas";
-import { chartDataSchema, validateChartData } from "../chart_schemas.js";
+import { resolvePosition } from "#blokkli/agent/app/tools/helpers";
+import {
+  chartDataSchema,
+  validateChartData,
+  findChartBundle
+} from "../chart_schemas.js";
 import { COLORS } from "#blokkli-build/charts-config";
 const paramsSchema = z.object({
   chart: chartDataSchema,
@@ -25,24 +29,19 @@ export default defineBlokkliAgentTool({
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
-  requiredAdapterMethods: ["fragmentsAddBlock"],
+  requiredAdapterMethods: ["addNewBlocks"],
   execute(ctx, params) {
-    const { fields, definitions } = ctx.app;
-    const fragment = definitions.fragmentDefinitions.value.find(
-      (f) => f.name === "blokkli_chart"
-    );
-    if (!fragment) {
-      return { error: 'Chart fragment "blokkli_chart" is not available.' };
-    }
+    const { fields } = ctx.app;
     const field = fields.find(params.parent.uuid, params.parent.field);
     if (!field) {
       return {
         error: `Field not found: ${params.parent.field} on entity ${params.parent.uuid}`
       };
     }
-    if (!field.allowedFragments.includes("blokkli_chart")) {
+    const chartBundle = findChartBundle(ctx, field.allowedBundles);
+    if ("error" in chartBundle) {
       return {
-        error: `Field "${params.parent.field}" does not allow the "blokkli_chart" fragment. Allowed fragments: ${field.allowedFragments.length ? field.allowedFragments.join(", ") : "none"}`
+        error: `No block type with a chart option is allowed in field "${params.parent.field}". Allowed bundles: ${field.allowedBundles.length ? field.allowedBundles.join(", ") : "none"}`
       };
     }
     const chartData = {
@@ -68,18 +67,26 @@ export default defineBlokkliAgentTool({
     );
     if ("error" in resolved) return resolved;
     const { $t } = ctx.app;
+    const blockUuid = crypto.randomUUID();
     return {
       type: "add",
       label: $t("aiAgentCreateChartDone", "Added chart"),
-      apply: (adapter) => adapter.fragmentsAddBlock({
-        name: "blokkli_chart",
+      apply: (adapter) => adapter.addNewBlocks({
+        blocks: [
+          {
+            bundle: chartBundle.bundle,
+            blockUuid,
+            options: {
+              [chartBundle.key]: JSON.stringify(result.data)
+            }
+          }
+        ],
         host: {
           type: params.parent.type,
           uuid: params.parent.uuid,
           fieldName: params.parent.field
         },
-        preceedingUuid: resolved.afterUuid,
-        options: { data: JSON.stringify(result.data) }
+        afterUuid: resolved.afterUuid
       })
     };
   }

package/dist/modules/charts/runtime/blokkli/tools/get_chart_data/index.js

@@ -1,9 +1,13 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { chartTypeEnum, chartColorEnum, chartSeriesSchema } from "../chart_schemas.js";
+import {
+  chartTypeEnum,
+  chartColorEnum,
+  chartSeriesSchema,
+  findChartOptionKey
+} from "../chart_schemas.js";
 import { COLORS } from "#blokkli-build/charts-config";
-import { getDefaultChartData } from "#blokkli/charts/types";
-import { fragmentBlockBundle } from "#blokkli-build/config";
+import { getDefaultChartData } from "../../../helpers/index.js";
 const paramsSchema = z.object({
   uuid: z.string().describe("UUID of the chart paragraph")
 });
@@ -30,23 +34,11 @@ export default defineBlokkliAgentTool({
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { blocks, state, $t } = ctx.app;
-    const block = blocks.getBlock(params.uuid);
-    if (!block) {
-      return { error: `Paragraph not found: ${params.uuid}` };
-    }
-    if (block.bundle !== fragmentBlockBundle) {
-      return {
-        error: `Paragraph "${params.uuid}" is a "${block.bundle}", not a fragment.`
-      };
-    }
-    if (block.fragment?.name !== "blokkli_chart") {
-      return {
-        error: `Fragment "${params.uuid}" is a "${block.fragment?.name}", not a "blokkli_chart".`
-      };
-    }
+    const { state, $t } = ctx.app;
+    const chartOption = findChartOptionKey(ctx, params.uuid);
+    if ("error" in chartOption) return chartOption;
     const item = state.getFieldListItem(params.uuid);
-    const rawData = item?.options?.data;
+    const rawData = item?.options?.[chartOption.key];
     let data;
     if (rawData) {
       try {

package/dist/modules/charts/runtime/blokkli/tools/get_chart_type_options/index.js

@@ -1,9 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  blockOptionsMapSchema,
-  buildBlockOptionsMapFromDefinitions
-} from "#blokkli/agent/app/tools/schemas";
+import { blockOptionsMapSchema } from "#blokkli/agent/app/tools/schemas";
+import { buildBlockOptionsMapFromDefinitions } from "#blokkli/agent/app/tools/helpers";
 import { getChartTypeRuntime } from "../../../chartTypes/index.js";
 import { chartTypeEnum } from "../chart_schemas.js";
 const paramsSchema = z.object({

package/dist/modules/charts/runtime/blokkli/tools/update_chart/index.js

@@ -5,11 +5,11 @@ import {
   chartTypeEnum,
   chartColorEnum,
   chartSeriesSchema,
-  validateChartData
+  validateChartData,
+  findChartOptionKey
 } from "../chart_schemas.js";
 import { COLORS } from "#blokkli-build/charts-config";
-import { getDefaultChartData } from "#blokkli/charts/types";
-import { fragmentBlockBundle } from "#blokkli-build/config";
+import { getDefaultChartData } from "../../../helpers/index.js";
 const paramsSchema = z.object({
   uuid: z.string().describe("UUID of the chart paragraph to update"),
   title: z.string().optional().describe("Chart title"),
@@ -42,24 +42,12 @@ export default defineBlokkliAgentTool({
   resultSchema: mutationResultSchema,
   requiredAdapterMethods: ["updateOptions"],
   execute(ctx, params) {
-    const { blocks, state } = ctx.app;
-    const block = blocks.getBlock(params.uuid);
-    if (!block) {
-      return { error: `Paragraph not found: ${params.uuid}` };
-    }
-    if (block.bundle !== fragmentBlockBundle) {
-      return {
-        error: `Paragraph "${params.uuid}" is a "${block.bundle}", not a "${fragmentBlockBundle}".`
-      };
-    }
-    if (block.fragment?.name !== "blokkli_chart") {
-      return {
-        error: `Fragment "${params.uuid}" is a "${block.fragment?.name}", not a "blokkli_chart".`
-      };
-    }
+    const { state } = ctx.app;
+    const chartOption = findChartOptionKey(ctx, params.uuid);
+    if ("error" in chartOption) return chartOption;
     let current;
     const item = state.getFieldListItem(params.uuid);
-    const rawData = item?.options?.data;
+    const rawData = item?.options?.[chartOption.key];
     if (rawData) {
       try {
         current = JSON.parse(rawData);
@@ -92,7 +80,7 @@ export default defineBlokkliAgentTool({
       apply: (adapter) => adapter.updateOptions([
         {
           uuid: params.uuid,
-          key: "data",
+          key: chartOption.key,
           value: JSON.stringify(result.data)
         }
       ])

package/dist/modules/charts/runtime/chartTypes/area.d.ts

@@ -1,2 +1,7 @@
-declare const _default: import("./types.js").ChartTypeFactory;
+import type { XAxisTypeOptions, DataLabelsTypeOptions, LegendTypeOptions, GridTypeOptions, StrokeWidthTypeOptions } from './shared.js';
+export type TypeOptions = {
+    curved: boolean;
+    markers: boolean;
+} & XAxisTypeOptions & DataLabelsTypeOptions & LegendTypeOptions & GridTypeOptions & StrokeWidthTypeOptions;
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
 export default _default;

package/dist/modules/charts/runtime/chartTypes/bar.d.ts

@@ -1,2 +1,8 @@
-declare const _default: import("./types.js").ChartTypeFactory;
+import type { XAxisTypeOptions, DataLabelsTypeOptions, LegendTypeOptions, GridTypeOptions } from './shared.js';
+export type TypeOptions = {
+    stacked: boolean;
+    horizontal: boolean;
+    borderRadius: string;
+} & XAxisTypeOptions & DataLabelsTypeOptions & LegendTypeOptions & GridTypeOptions;
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
 export default _default;

package/dist/modules/charts/runtime/chartTypes/define.d.ts

@@ -1,2 +1,2 @@
 import type { ChartTypeFactory } from './types.js';
-export declare function defineChartType(factory: ChartTypeFactory): ChartTypeFactory;
+export declare function defineChartType<T extends Record<string, unknown>>(factory: ChartTypeFactory<T>): ChartTypeFactory<T>;

package/dist/modules/charts/runtime/chartTypes/donut.d.ts

@@ -1,2 +1,6 @@
-declare const _default: import("./types.js").ChartTypeFactory;
+export type TypeOptions = {
+    showTotal: boolean;
+    showLabels: boolean;
+};
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
 export default _default;

package/dist/modules/charts/runtime/chartTypes/heatmap.d.ts

@@ -1,2 +1,4 @@
-declare const _default: import("./types.js").ChartTypeFactory;
+import type { XAxisTypeOptions, LegendTypeOptions, GridTypeOptions } from './shared.js';
+export type TypeOptions = XAxisTypeOptions & LegendTypeOptions & GridTypeOptions;
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
 export default _default;

package/dist/modules/charts/runtime/chartTypes/index.d.ts

@@ -1,4 +1,22 @@
 import type { TranslateFunction, ChartTypeDefinition } from './types.js';
+import type { TypeOptions as BarTypeOptions } from './bar.js';
+import type { TypeOptions as LineTypeOptions } from './line.js';
+import type { TypeOptions as AreaTypeOptions } from './area.js';
+import type { TypeOptions as PieTypeOptions } from './pie.js';
+import type { TypeOptions as DonutTypeOptions } from './donut.js';
+import type { TypeOptions as HeatmapTypeOptions } from './heatmap.js';
+import type { TypeOptions as RadialBarTypeOptions } from './radialBar.js';
+import type { TypeOptions as RadarTypeOptions } from './radar.js';
+export type ChartTypeOptionsMap = {
+    bar: BarTypeOptions;
+    line: LineTypeOptions;
+    area: AreaTypeOptions;
+    pie: PieTypeOptions;
+    donut: DonutTypeOptions;
+    heatmap: HeatmapTypeOptions;
+    radialBar: RadialBarTypeOptions;
+    radar: RadarTypeOptions;
+};
 /**
  * Get a chart type definition using fallback labels (no real translations).
  * Used by ChartRenderer which runs in both edit mode and production.

package/dist/modules/charts/runtime/chartTypes/line.d.ts

@@ -1,2 +1,7 @@
-declare const _default: import("./types.js").ChartTypeFactory;
+import type { XAxisTypeOptions, DataLabelsTypeOptions, LegendTypeOptions, GridTypeOptions, StrokeWidthTypeOptions } from './shared.js';
+export type TypeOptions = {
+    curved: boolean;
+    markers: boolean;
+} & XAxisTypeOptions & DataLabelsTypeOptions & LegendTypeOptions & GridTypeOptions & StrokeWidthTypeOptions;
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
 export default _default;

package/dist/modules/charts/runtime/chartTypes/pie.d.ts

@@ -1,2 +1,5 @@
-declare const _default: import("./types.js").ChartTypeFactory;
+export type TypeOptions = {
+    showLabels: boolean;
+};
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
 export default _default;

package/dist/modules/charts/runtime/chartTypes/radar.d.ts

@@ -1,2 +1,7 @@
-declare const _default: import("./types.js").ChartTypeFactory;
+import type { DataLabelsTypeOptions, LegendTypeOptions } from './shared.js';
+export type TypeOptions = {
+    markers: boolean;
+    fillOpacity: string;
+} & DataLabelsTypeOptions & LegendTypeOptions;
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
 export default _default;

package/dist/modules/charts/runtime/chartTypes/radialBar.d.ts

@@ -1,2 +1,6 @@
-declare const _default: import("./types.js").ChartTypeFactory;
+export type TypeOptions = {
+    showLabels: boolean;
+    showTotal: boolean;
+};
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
 export default _default;

package/dist/modules/charts/runtime/chartTypes/shared.d.ts

@@ -4,6 +4,21 @@ import type { TranslateFunction } from './types.js';
 type SharedOptions = {
     options: Record<string, BlockOptionDefinitionBase<BlokkliIcon>>;
 };
+export type XAxisTypeOptions = {
+    xaxisRotation: string;
+};
+export type DataLabelsTypeOptions = {
+    dataLabels: boolean;
+};
+export type LegendTypeOptions = {
+    legendPosition: string;
+};
+export type GridTypeOptions = {
+    gridLines: boolean;
+};
+export type StrokeWidthTypeOptions = {
+    strokeWidth: string;
+};
 /**
  * Shared x-axis label options for chart types that display an x-axis.
  */
@@ -12,7 +27,7 @@ export declare function xAxisOptions($t: TranslateFunction): SharedOptions;
  * Build x-axis label config from type options.
  * Returns properties to merge into the xaxis config object.
  */
-export declare function buildXAxisLabelOptions(typeOptions: Record<string, unknown>): Record<string, any>;
+export declare function buildXAxisLabelOptions(typeOptions: XAxisTypeOptions): Record<string, any>;
 /**
  * Data labels option — show values directly on chart elements.
  */
@@ -20,7 +35,7 @@ export declare function dataLabelsOptions($t: TranslateFunction): SharedOptions;
 /**
  * Build data labels config from type options.
  */
-export declare function buildDataLabelsOptions(typeOptions: Record<string, unknown>): Record<string, any>;
+export declare function buildDataLabelsOptions(typeOptions: DataLabelsTypeOptions): Record<string, any>;
 /**
  * Legend position option for multi-series chart types.
  */
@@ -28,7 +43,7 @@ export declare function legendOptions($t: TranslateFunction): SharedOptions;
 /**
  * Build legend config from type options.
  */
-export declare function buildLegendOptions(typeOptions: Record<string, unknown>): Record<string, any>;
+export declare function buildLegendOptions(typeOptions: LegendTypeOptions): Record<string, any>;
 /**
  * Grid lines option for chart types with axes.
  */
@@ -36,7 +51,7 @@ export declare function gridOptions($t: TranslateFunction): SharedOptions;
 /**
  * Build grid config from type options.
  */
-export declare function buildGridOptions(typeOptions: Record<string, unknown>): Record<string, any>;
+export declare function buildGridOptions(typeOptions: GridTypeOptions): Record<string, any>;
 /**
  * Stroke width option for line-based chart types.
  */
@@ -44,7 +59,7 @@ export declare function strokeWidthOptions($t: TranslateFunction): SharedOptions
 /**
  * Build stroke width config from type options.
  */
-export declare function buildStrokeWidthOptions(typeOptions: Record<string, unknown>): Record<string, any>;
+export declare function buildStrokeWidthOptions(typeOptions: StrokeWidthTypeOptions): Record<string, any>;
 /**
  * Merge multiple shared option sets into one.
  */

package/dist/modules/charts/runtime/chartTypes/types.d.ts

@@ -1,7 +1,7 @@
 import type { BlokkliIcon } from '#blokkli-build/icons';
 import type { BlockOptionDefinitionBase } from '../../../../global/types/blockOptions.js';
 export type TranslateFunction = (key: string, fallback: string) => string;
-export type ChartBuildContext = {
+export type ChartBuildContext<T extends Record<string, unknown> = Record<string, unknown>> = {
     title: string;
     categories: string[];
     series: Array<{
@@ -11,19 +11,19 @@ export type ChartBuildContext = {
     }>;
     seriesColors: string[];
     categoryColors: string[];
-    typeOptions: Record<string, unknown>;
+    typeOptions: T;
 };
-export type ChartTypeDefinition = {
+export type ChartTypeDefinition<T extends Record<string, unknown> = Record<string, unknown>> = {
     id: string;
     hasMultipleSeries: boolean;
     hasSeriesColors: boolean;
     hasCategoryColors: boolean;
-    buildChartOptions: (ctx: ChartBuildContext) => Record<string, any>;
-    buildSeries: (ctx: ChartBuildContext) => any;
+    buildChartOptions: (ctx: ChartBuildContext<T>) => Record<string, any>;
+    buildSeries: (ctx: ChartBuildContext<T>) => any;
     editor: {
         label: string;
         icon: BlokkliIcon;
         options: Record<string, BlockOptionDefinitionBase<BlokkliIcon>>;
     };
 };
-export type ChartTypeFactory = ($t: TranslateFunction) => ChartTypeDefinition;
+export type ChartTypeFactory<T extends Record<string, unknown> = Record<string, unknown>> = ($t: TranslateFunction) => ChartTypeDefinition<T>;