@figulus/schema 0.4.0-alpha-dev → 0.5.0-alpha-dev-2

package/src/engine/paths/volumes.ts

@@ -0,0 +1,168 @@
+import { RouteConfig } from "@asteasolutions/zod-to-openapi";
+import { deleteVolumeResponseSchema, ensureVolumeRequestSchema, ensureVolumeResponseSchema, listVolumesResponseSchema, pruneVolumesRequestSchema, pruneVolumesResponseSchema } from "../volumes.js";
+import { errorResponseSchema } from "../response.js";
+
+export const ensureVolumeRouteSchema: RouteConfig = {
+  method: "post",
+  path: "/api/v1/volumes/ensure",
+  operationId: "ensureVolume",
+  summary: "Ensure a Docker volume exists",
+  description: "Creates the volume if it does not exist; no-ops if it does.",
+  tags: [
+    "volumes"
+  ],
+  request: {
+    body: {
+      description: undefined,
+      content: {
+        "application/json": {
+          schema: ensureVolumeRequestSchema
+        }
+      },
+      required: true
+    }
+  },
+  responses: {
+    200: {
+      description: "Volume exists (created or pre-existing)",
+      content: {
+        "application/json": {
+          schema: ensureVolumeResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Missing volume_name",
+      content: {
+        "application/json": {
+          schema: errorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Failed to ensure volume",
+      content: {
+        "application/json": {
+          schema: errorResponseSchema
+        }
+      }
+    }
+  }
+};
+
+export const listVolumesRouteSchema: RouteConfig = {
+  method: "get",
+  path: "/api/v1/volumes",
+  operationId: "listVolumes",
+  summary: "List Figulus-managed volumes",
+  description: "Returns all Docker volumes managed by this Figulus engine instance.",
+  tags: [
+    "volumes"
+  ],
+  responses: {
+    200: {
+      description: "Volume list",
+      content: {
+        "application/json": {
+          schema: listVolumesResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Failed to list volumes",
+      content: {
+        "application/json": {
+          schema: errorResponseSchema
+        }
+      }
+    }
+  }
+};
+
+export const deleteVolumeRouteSchema: RouteConfig = {
+  method: "delete",
+  path: "/api/v1/volumes/{name}",
+  operationId: "deleteVolume",
+  summary: "Delete a volume",
+  description: "Deletes the named Docker volume. Returns 500 if the volume is in use.",
+  tags: [
+    "volumes"
+  ],
+  parameters: [
+    {
+      name: "name",
+      in: "path",
+      required: true,
+      schema: {
+        type: "string"
+      },
+      example: "figulus-cache-nodejs"
+    }
+  ],
+  responses: {
+    200: {
+      description: "Volume deleted",
+      content: {
+        "application/json": {
+          schema: deleteVolumeResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Missing volume name",
+      content: {
+        "application/json": {
+          schema: errorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Delete failed",
+      content: {
+        "application/json": {
+          schema: errorResponseSchema
+        }
+      }
+    }
+  }
+};
+
+export const pruneVolumesRouteSchema: RouteConfig = {
+  method: "post",
+  path: "/api/v1/volumes/prune",
+  operationId: "pruneVolumes",
+  summary: "Prune unused volumes",
+  description: "Removes unused Docker volumes matching the given filters. Body is optional.",
+  tags: [
+    "volumes"
+  ],
+  request: {
+    body: {
+      description: undefined,
+      content: {
+        "application/json": {
+          schema: pruneVolumesRequestSchema
+        }
+      },
+      required: false
+    }
+  },
+  responses: {
+    200: {
+      description: "Volumes pruned",
+      content: {
+        "application/json": {
+          schema: pruneVolumesResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Prune failed",
+      content: {
+        "application/json": {
+          schema: errorResponseSchema
+        }
+      }
+    }
+  }
+};

package/src/engine/response.ts

@@ -0,0 +1,11 @@
+import z from "zod";
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+
+extendZodWithOpenApi(z);
+
+export const errorResponseSchema = z.object({
+  error: z.string().describe("Machine-readable error code").openapi({ example: "job_not_found" }),
+  message: z.string().describe("Human-readable error detail").openapi({ example: "Job abc123 not found" }),
+  code: z.int().describe("HTTP status code mirrored in body").openapi({ example: 404 }),
+}).openapi("ErrorResponse");
+export type ErrorResponse = z.infer<typeof errorResponseSchema>;

package/src/engine/sessions.ts

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+import {
+  namedVolumeMountSchema,
+  volumeMountSchema
+} from '../core/volumes.js';
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { figStackSchema } from '../core/entities/figstack.js';
+import { figSpecExecuteSchema } from '../core/entities/figspec.js';
+import { portMappingSchema } from '../core/generic.js';
+extendZodWithOpenApi(z);
+
+export const sessionStatusSchema = z.enum([
+  'active', 'idle', 'expired'
+]).openapi("SessionStatus");
+export type SessionStatus = z.infer<typeof sessionStatusSchema>;
+
+export const sessionConfigSchema = z.object({
+  working_dir: z.string().optional().describe("Default working directory for commands in this session").openapi({ example: "/app" }),
+  environment: z.record(z.string(), z.string()).optional().describe("Environment variables for the session container"),
+  parser_script: z.string().optional().describe("Default JavaScript parser script for command output"),
+  volumes: z.array(volumeMountSchema).optional(),
+  named_volumes: z.array(namedVolumeMountSchema).optional(),
+  init_cmd: z.array(z.string()).optional().describe("Command to run once after container creation"),
+  destroy_cmd: z.array(z.string()).optional().describe("Command to run before container destruction"),
+  execute: figSpecExecuteSchema.optional().describe("Figspec execute configuration (alternative to start_cmd for Figspec-driven sessions)"),
+  ports: z.array(portMappingSchema).optional(),
+  start_cmd: z.array(z.string()).optional().describe("Main container process command (default [\"sleep\", \"infinity\"])"),
+  auto_cleanup: z.boolean().optional().describe("If true, the session is destroyed automatically after the main command (start_cmd or execute.main) completes, regardless of exit code. This is the flag that distinguishes a one-shot execution from a persistent session.").openapi({ example: false }),
+  block_until_complete: z.boolean().optional().describe("If true (on CreateSessionRequest), the HTTP handler blocks until the session reaches a terminal state and returns the full result (exit_code, stdout, stderr) in the response. Intended for use with auto_cleanup: true to implement synchronous one-shot execution.").openapi({ example: false })
+}).openapi("SessionConfig");
+export type SessionConfig = z.infer<typeof sessionConfigSchema>;
+
+export const createSessionRequestSchema = z.object({
+  image_tag: z.string().min(1).describe("Docker image to use for the session container").openapi({ example: "localhost:5000/figulus:sha256-abc123" }),
+  ttl: z.int().positive().optional().describe("Session TTL in seconds (default 600)").openapi({ example: 600 }),
+  config: sessionConfigSchema.optional(),
+  execute: figSpecExecuteSchema.optional().describe("Figspec execute configuration (preferred over config.start_cmd for Figspec-driven sessions)"),
+  block_until_complete: z.boolean().optional().describe("If true, the HTTP handler blocks until the session reaches a terminal state and returns the full result (exit_code, stdout, stderr) synchronously. Use with config.auto_cleanup: true to implement one-shot execution semantics (replaces the removed /containers/run endpoint).").openapi({ example: false }),
+}).openapi("CreateSessionRequest");
+export type CreateSessionRequest = z.infer<typeof createSessionRequestSchema>;
+
+export const createSessionResponseSchema = z.object({
+  session_id: z.string().openapi({ example: "sess-abc123" }),
+  container_id: z.string().openapi({ example: "a1b2c3d4e5f6" }),
+  status: sessionStatusSchema,
+  created_at: z.iso.datetime().openapi({ format: "date-time" }),
+  ports: z.array(portMappingSchema).optional(),
+  exit_code: z.int().optional().describe("Container exit code. Populated when block_until_complete: true and the session ran to completion (i.e., auto_cleanup: true and the main command finished).").openapi({ example: 0 }),
+  stdout: z.string().optional().describe("Main command stdout. Populated when block_until_complete is true and session ran to completion.").openapi({ example: "Hello, world!\n" }),
+  stderr: z.string().optional().describe("Main command stderr. Populated when block_until_complete is true and session ran to completion.").openapi({ example: "" }),
+}).openapi("CreateSessionResponse");
+export type CreateSessionResponse = z.infer<typeof createSessionResponseSchema>;
+
+export const getSessionResponseSchema = z.object({
+  session_id: z.string(),
+  container_id: z.string(),
+  image_tag: z.string(),
+  status: sessionStatusSchema,
+  created_at: z.iso.datetime().openapi({ format: "date-time" }),
+  last_used_at: z.iso.datetime().openapi({ format: "date-time" }),
+  ttl: z.int().describe("TTL in seconds"),
+  ports: z.array(portMappingSchema).optional(),
+}).openapi("GetSessionResponse");
+export type GetSessionResponse = z.infer<typeof getSessionResponseSchema>;
+
+export const runInSessionRequestSchema = z.object({
+  command: z.array(z.string()).min(1).describe("Command to execute inside the session container").openapi({ example: ["npm","test"] }),
+  timeout: z.int().positive().max(86400).optional().describe("Timeout in seconds (default 300)").openapi({ example: 300 }),
+  parser_script: z.string().optional().describe("Optional JavaScript parser for structured output"),
+  working_dir: z.string().optional().describe("Override the session working directory for this run").openapi({ example: "/app/packages/core" }),
+}).openapi("RunInSessionRequest");
+export type RunInSessionRequest = z.infer<typeof runInSessionRequestSchema>;
+
+export const runInSessionResponseSchema = z.object({
+  run_id: z.string().openapi({ example: "run-abc123" }),
+  exit_code: z.int(),
+  stdout: z.string(),
+  stderr: z.string(),
+  parsed_output: z.record(z.string(), z.unknown()).optional().describe("Structured output from the parser script, if provided"),
+  duration: z.number().describe("Duration in seconds").openapi({ format: "double" }),
+}).openapi("RunInSessionResponse");
+export type RunInSessionResponse = z.infer<typeof runInSessionResponseSchema>;
+
+export const getRunResponseSchema = z.object({
+  run_id: z.string(),
+  session_id: z.string(),
+  command: z.array(z.string()),
+  exit_code: z.int(),
+  stdout: z.string(),
+  stderr: z.string(),
+  parsed_output: z.record(z.string(), z.unknown()).optional(),
+  started_at: z.iso.datetime().openapi({ format: "date-time" }),
+  completed_at: z.iso.datetime().openapi({ format: "date-time" }),
+  duration: z.number().openapi({ format: "double" }),
+}).openapi("GetRunResponse");
+export type GetRunResponse = z.infer<typeof getRunResponseSchema>;
+
+export const listRunsResponseSchema = z.object({
+    runs: z.array(getRunResponseSchema),
+    count: z.int()
+}).openapi("ListRunsResponse");
+
+export const syncFileRequestSchema = z.object({
+  targetPath: z.string().min(1).describe("Absolute path inside the container where the file will be written").openapi({ example: "/app/src/index.ts" }),
+  content: z.string().min(1).describe("File content, encoded as specified by the encoding field"),
+  encoding: z.enum(['base64', 'utf8']).default('base64').describe("Encoding of the content field (default base64)"),
+}).openapi("SyncFileRequest");
+export type SyncFileRequest = z.infer<typeof syncFileRequestSchema>;
+
+export const syncFileResponseSchema = z.object({
+  success: z.boolean(),
+  path: z.string().describe("Path written to (echoes targetPath)"),
+  bytes_written: z.int().openapi({ format: "int64" }),
+  message: z.string().optional(),
+}).openapi("SyncFileResponse");
+export type SyncFileResponse = z.infer<typeof syncFileResponseSchema>;
+
+export const startStackRequestSchema = z.object({
+    spec: figStackSchema,
+    build: z.boolean().optional().default(false).describe("If true, build all required images before starting."),
+    images: z.object({}).optional().describe("Pre-resolved image tags keyed by container entry name."),
+}).openapi("StartStackRequest");
+
+export const startStackResponseSchema = z.object({
+    stack_name: z.string(),
+    sessions: z.object({}).describe("Map of container name → session ID."),
+    network_id: z.string()
+}).openapi("StartStackResponse");
+
+export const stackContainerStatusSchema = z.object({
+    container_name: z.string(),
+    session_id: z.string(),
+    status: z.string()
+}).openapi("StackContainerStatus");
+
+export const getStackResponseSchema = z.object({
+    stack_name: z.string(),
+    network_id: z.string(),
+    containers: z.array(stackContainerStatusSchema),
+    created_at: z.iso.datetime().openapi({ format: "date-time" }),
+}).openapi("GetStackResponse");
+
+export const listStacksResponseSchema = z.object({
+    stacks: z.array(getRunResponseSchema),
+    count: z.int()
+}).openapi("ListStacksResponse");

package/src/engine/volumes.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+
+extendZodWithOpenApi(z);
+
+export const ensureVolumeRequestSchema = z.object({
+  volume_name: z.string().min(1).describe("Docker volume name to ensure exists").openapi({ example: "figulus-cache-nodejs" }),
+  driver: z.string().optional().describe("Volume driver (default \"local\")").openapi({ example: "local" }),
+  labels: z.record(z.string(), z.string()).optional().describe("Labels to apply when creating the volume"),
+}).openapi("EnsureVolumeRequest");
+export type EnsureVolumeRequest = z.infer<typeof ensureVolumeRequestSchema>;
+
+export const ensureVolumeResponseSchema = z.object({
+  volume_name: z.string(),
+  created: z.boolean().describe("true if the volume was newly created, false if it already existed"),
+  message: z.string().optional(),
+}).openapi("EnsureVolumeResponse");
+export type EnsureVolumeResponse = z.infer<typeof ensureVolumeResponseSchema>;
+
+export const volumeInfoSchema = z.object({
+  name: z.string(),
+  driver: z.string(),
+  mountpoint: z.string(),
+  created_at: z.string(),
+  labels: z.record(z.string(), z.string()).optional(),
+  scope: z.string(),
+  size_bytes: z.int().optional().describe("Volume size; may not be available on all Docker versions").openapi({ format: "int64" }),
+}).openapi("VolumeInfo");
+export type VolumeInfo = z.infer<typeof volumeInfoSchema>;
+
+export const listVolumesResponseSchema = z.object({
+  volumes: z.array(volumeInfoSchema),
+  count: z.int(),
+}).openapi("ListVolumesResponse");
+export type ListVolumesResponse = z.infer<typeof listVolumesResponseSchema>;
+
+export const deleteVolumeResponseSchema = z.object({
+  volume_name: z.string(),
+  message: z.string(),
+}).openapi("DeleteVolumeResponse");
+export type DeleteVolumeResponse = z.infer<typeof deleteVolumeResponseSchema>;
+
+export const pruneVolumesRequestSchema = z.object({
+  filters: z.record(z.string(), z.array(z.string())).optional().describe("Docker filter map, e.g. {\"label\": [\"figulus.cache.language=nodejs\"]}"),
+}).openapi("PruneVolumesRequest");
+export type PruneVolumesRequest = z.infer<typeof pruneVolumesRequestSchema>;
+
+export const pruneVolumesResponseSchema = z.object({
+  volumes_deleted: z.array(z.string()).describe("Names of volumes that were deleted"),
+  space_reclaimed: z.int().describe("Bytes freed").openapi({ format: "int64" }),
+  message: z.string(),
+}).openapi("PruneVolumesResponse");
+export type PruneVolumesResponse = z.infer<typeof pruneVolumesResponseSchema>;

package/src/index.ts

@@ -1,8 +1,3 @@
-export * from './shared.js';
-export * from './health.js';
-export * from './run-request.js';
-export * from './image.js';
-export * from './volume.js';
-export * from './session.js';
-export * from './figspec.js';
-export * from './figstack.js';
+export * from './core/index.js';
+export * from './engine/index.js';
+export * from './registry/index.js';

package/src/registry/index.ts

@@ -0,0 +1,2 @@
+export * from "./json-schema.js";
+export * from "./metadata.js";

package/src/registry/json-schema.ts

@@ -0,0 +1,178 @@
+import { z } from "zod";
+
+const JsonSchemaTypeNameSchema = z.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null",
+]).describe("JSON Schema type name");
+
+const JsonValueSchema: z.ZodType = z.lazy(() =>
+  z.union([
+    z.null(),
+    z.boolean(),
+    z.number(),
+    z.string(),
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema),
+  ]),
+);
+
+// Reusable: array of strings with no duplicates
+const uniqueStringArray = () =>
+  z.array(z.string()).superRefine((arr, ctx) => {
+    const seen = new Set<string>();
+    arr.forEach((el, i) => {
+      if (seen.has(el)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Duplicate value "${el}" at index ${i}`,
+          path: [i],
+        });
+      }
+      seen.add(el);
+    });
+  });
+
+// Array of unique type name values
+const typeNameArray = z
+  .array(JsonSchemaTypeNameSchema)
+  .superRefine((arr, ctx) => {
+    const seen = new Set<string>();
+    arr.forEach((el, i) => {
+      if (seen.has(el)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Duplicate type "${el}" at index ${i}`,
+          path: [i],
+        });
+      }
+      seen.add(el);
+    });
+  });
+
+// Declared before JsonSchemaSchema so all lazy references below are genuinely
+// necessary to defer evaluation until JsonSchemaSchema is assigned.
+const JsonSchemaObjectSchema = z
+  .object({
+    // ── Core ────────────────────────────────────────────────────────────
+    $schema: z.string().optional()
+      .describe("§7: MUST be a URI (RFC 3986) with a scheme — not necessarily an http URL"),
+    $id: z.string().optional()
+      .describe("§8.2: MUST be a URI-reference — includes relative refs like \"#foo\", \"other.json\""),
+    $ref: z.string().optional()
+      .describe("§8.3: MUST be a URI Reference"),
+    $comment: z.string().optional()
+      .describe("§9: MUST be a string"),
+
+    // ── Metadata ────────────────────────────────────────────────────────
+    title: z.string().optional(),
+    description: z.string().optional(),
+    default: JsonValueSchema.optional()
+      .describe("§10.2: no restrictions on value"),
+    examples: z.array(JsonValueSchema).optional()
+      .describe("§10.4: MUST be an array, no restrictions on elements"),
+    readOnly: z.boolean().optional(),
+    writeOnly: z.boolean().optional(),
+
+    // ── Type ────────────────────────────────────────────────────────────
+    type: z.union([JsonSchemaTypeNameSchema, typeNameArray]).optional()
+      .describe("§6.1.1: string or array of unique type names; no minimum length on array form"),
+
+    // ── Enum / Const ────────────────────────────────────────────────────
+    enum: z.array(JsonValueSchema).optional()
+      .describe("§6.1.2: SHOULD have ≥1 element (SHOULD not MUST — no .min(1))"),
+    const: JsonValueSchema.optional()
+      .describe("§6.1.3: MAY be any type including null"),
+
+    // ── Numeric ─────────────────────────────────────────────────────────
+    multipleOf: z.number().positive().optional()
+      .describe("§6.2.1: MUST be a number strictly greater than 0"),
+    maximum: z.number().optional(),
+    exclusiveMaximum: z.number().optional()
+      .describe("§6.2.3: MUST be a number (exclusive bounds are numbers in Draft-07, not booleans)"),
+    minimum: z.number().optional(),
+    exclusiveMinimum: z.number().optional(),
+
+    // ── String ──────────────────────────────────────────────────────────
+    maxLength: z.int().nonnegative().optional()
+      .describe("§6.3.1–6.3.2: MUST be a non-negative integer"),
+    minLength: z.int().nonnegative().optional()
+      .describe("§6.3.1–6.3.2: MUST be a non-negative integer"),
+    pattern: z.string().optional(),
+    format: z.string().optional(),
+    contentMediaType: z.string().optional(),
+    contentEncoding: z.string().optional(),
+
+    // ── Array ───────────────────────────────────────────────────────────
+    items: z
+      .lazy(() => z.union([JsonSchemaSchema, z.array(JsonSchemaSchema)]))
+      .optional()
+      .describe("§6.4.1: MUST be a valid JSON Schema or an array of valid JSON Schemas"),
+    additionalItems: z.lazy(() => JsonSchemaSchema).optional()
+      .describe("§6.4.2: MUST be a valid JSON Schema"),
+    maxItems: z.int().nonnegative().optional()
+      .describe("§6.4.3–6.4.4: MUST be a non-negative integer"),
+    minItems: z.int().nonnegative().optional()
+      .describe("§6.4.3–6.4.4: MUST be a non-negative integer"),
+    uniqueItems: z.boolean().optional(),
+    contains: z.lazy(() => JsonSchemaSchema).optional()
+      .describe("§6.4.6: MUST be a valid JSON Schema"),
+
+    // ── Object ──────────────────────────────────────────────────────────
+    maxProperties: z.int().nonnegative().optional()
+      .describe("§6.5.1–6.5.2: MUST be a non-negative integer"),
+    minProperties: z.int().nonnegative().optional()
+      .describe("§6.5.1–6.5.2: MUST be a non-negative integer"),
+    required: uniqueStringArray().optional()
+      .describe("§6.5.3: elements MUST be unique; empty array is explicitly valid"),
+    properties: z.lazy(() => z.record(z.string(), JsonSchemaSchema)).optional(),
+    patternProperties: z
+      .lazy(() => z.record(z.string(), JsonSchemaSchema))
+      .optional(),
+    additionalProperties: z.lazy(() => JsonSchemaSchema).optional(),
+    dependencies: z
+      .lazy(() =>
+        z.record(z.string(), z.union([JsonSchemaSchema, uniqueStringArray()])),
+      )
+      .optional()
+      .describe("§6.5.7: each value is a subschema OR an array of unique strings"),
+    propertyNames: z.lazy(() => JsonSchemaSchema).optional(),
+
+    // ── Conditional ─────────────────────────────────────────────────────
+    if: z.lazy(() => JsonSchemaSchema).optional(),
+    then: z.lazy(() => JsonSchemaSchema).optional(),
+    else: z.lazy(() => JsonSchemaSchema).optional(),
+
+    // ── Combiners ───────────────────────────────────────────────────────
+    allOf: z.lazy(() => z.array(JsonSchemaSchema).min(1)).optional()
+      .describe("§6.7.1–6.7.3: MUST be a non-empty array (min(1) is correct per spec)"),
+    anyOf: z.lazy(() => z.array(JsonSchemaSchema).min(1)).optional()
+      .describe("§6.7.1–6.7.3: MUST be a non-empty array (min(1) is correct per spec)"),
+    oneOf: z.lazy(() => z.array(JsonSchemaSchema).min(1)).optional()
+      .describe("§6.7.1–6.7.3: MUST be a non-empty array (min(1) is correct per spec)"),
+    not: z.lazy(() => JsonSchemaSchema).optional(),
+
+    // ── Definitions ─────────────────────────────────────────────────────
+    definitions: z
+      .lazy(() => z.record(z.string(), JsonSchemaSchema))
+      .optional()
+      .describe("§9: MUST be an object; each value MUST be a valid JSON Schema"),
+  })
+  // §4.3.1: unknown keywords SHOULD be ignored — loose preserves them
+  .loose();
+
+// Top-level: a schema is either a boolean or an object (§4.3.1)
+export const JsonSchemaSchema: z.ZodType = z.lazy(() =>
+  z.union([z.boolean(), JsonSchemaObjectSchema]),
+);
+
+// ── Inferred TypeScript types ──────────────────────────────────────────────────
+
+export type JsonSchemaTypeName = z.infer<typeof JsonSchemaTypeNameSchema>;
+export type JsonValue = z.infer<typeof JsonValueSchema>;
+export type JsonSchemaObject = z.infer<typeof JsonSchemaObjectSchema>;
+export type JsonSchema = z.infer<typeof JsonSchemaSchema>;