@suss/ir-core 0.3.1 → 0.4.0

package/dist/schemas.d.ts

@@ -1,374 +1,2 @@
-import { z } from 'zod';
-
-declare const ConfidenceSourceSchema: z.ZodEnum<{
-    inferred_static: "inferred_static";
-    inferred_ai: "inferred_ai";
-    declared: "declared";
-    derived: "derived";
-}>;
-declare const ConfidenceLevelSchema: z.ZodEnum<{
-    high: "high";
-    medium: "medium";
-    low: "low";
-}>;
-/**
- * The result of corroborating a claim against real execution
- * (`suss corroborate`): generated inputs satisfying the claim's own
- * conditions were run through the actual function and the observation
- * either agreed every time (`observed`), disagreed at least once
- * (`refuted` — an extractor bug or a genuine surprise; the
- * counterexample says which input), or never produced a verdict
- * (`untested` — no satisfying input was found, or every satisfying
- * run hit a dependency the harness cannot supply).
- *
- * Corroboration upgrades a *derivation* with *observations*; it is
- * additive evidence, never a rewrite of the derived claim.
- */
-declare const CorroborationSchema: z.ZodObject<{
-    outcome: z.ZodEnum<{
-        observed: "observed";
-        refuted: "refuted";
-        untested: "untested";
-    }>;
-    runs: z.ZodNumber;
-    counterexample: z.ZodOptional<z.ZodUnknown>;
-    reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const ConfidenceInfoSchema: z.ZodObject<{
-    source: z.ZodEnum<{
-        inferred_static: "inferred_static";
-        inferred_ai: "inferred_ai";
-        declared: "declared";
-        derived: "derived";
-    }>;
-    level: z.ZodEnum<{
-        high: "high";
-        medium: "medium";
-        low: "low";
-    }>;
-    corroboration: z.ZodOptional<z.ZodObject<{
-        outcome: z.ZodEnum<{
-            observed: "observed";
-            refuted: "refuted";
-            untested: "untested";
-        }>;
-        runs: z.ZodNumber;
-        counterexample: z.ZodOptional<z.ZodUnknown>;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const SourceLocationSchema: z.ZodObject<{
-    file: z.ZodString;
-    range: z.ZodObject<{
-        start: z.ZodNumber;
-        end: z.ZodNumber;
-    }, z.core.$strip>;
-    exportName: z.ZodNullable<z.ZodString>;
-    workspace: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const RestSemanticsSchema: z.ZodObject<{
-    name: z.ZodLiteral<"rest">;
-    method: z.ZodString;
-    path: z.ZodString;
-    declaredResponses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-}, z.core.$strip>;
-declare const FunctionCallSemanticsSchema: z.ZodObject<{
-    name: z.ZodLiteral<"function-call">;
-    module: z.ZodOptional<z.ZodString>;
-    exportName: z.ZodOptional<z.ZodString>;
-    package: z.ZodOptional<z.ZodString>;
-    exportPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-/**
- * Provider-side GraphQL resolver. One resolver binds one
- * (typeName, fieldName) pair. Pairing key: `${typeName}.${fieldName}`.
- */
-declare const GraphqlResolverSemanticsSchema: z.ZodObject<{
-    name: z.ZodLiteral<"graphql-resolver">;
-    typeName: z.ZodString;
-    fieldName: z.ZodString;
-}, z.core.$strip>;
-/**
- * Consumer-side GraphQL operation — a document sent from client to
- * server. Binds by operation name + type.
- */
-declare const GraphqlOperationSemanticsSchema: z.ZodObject<{
-    name: z.ZodLiteral<"graphql-operation">;
-    operationName: z.ZodOptional<z.ZodString>;
-    operationType: z.ZodEnum<{
-        query: "query";
-        mutation: "mutation";
-        subscription: "subscription";
-    }>;
-}, z.core.$strip>;
-/**
- * One thing that gets deployed and runs on its own: a Lambda
- * function, an ECS task's container, a plain container, a k8s
- * deployment.
- *
- * `instanceName` is the stable identifier the deployment medium uses:
- * the CFN logical resource id for Lambda and ECS, the deployment name
- * for k8s, the container name for a plain container.
- */
-declare const DeployableUnitSchema: z.ZodObject<{
-    deploymentTarget: z.ZodEnum<{
-        lambda: "lambda";
-        "ecs-task": "ecs-task";
-        container: "container";
-        "k8s-deployment": "k8s-deployment";
-    }>;
-    instanceName: z.ZodString;
-}, z.core.$strip>;
-/**
- * Provider-side runtime configuration channel: env vars and their
- * declared values on a deployable unit. The channel is the boundary;
- * env var names are FIELDS on its contract. Pairing key:
- * `(deploymentTarget, instanceName)`, which is exactly a deployable
- * unit, so the two fields come from `DeployableUnitSchema` rather
- * than being spelled a second time.
- */
-declare const RuntimeConfigSemanticsSchema: z.ZodObject<{
-    deploymentTarget: z.ZodEnum<{
-        lambda: "lambda";
-        "ecs-task": "ecs-task";
-        container: "container";
-        "k8s-deployment": "k8s-deployment";
-    }>;
-    instanceName: z.ZodString;
-    name: z.ZodLiteral<"runtime-config">;
-}, z.core.$strip>;
-/**
- * Provider-side relational storage table. Columns are FIELDS on the
- * table's contract. Pairing key: `(storageSystem, scope, table)`.
- */
-declare const StorageRelationalSemanticsSchema: z.ZodObject<{
-    name: z.ZodLiteral<"storage-relational">;
-    storageSystem: z.ZodEnum<{
-        postgres: "postgres";
-        mysql: "mysql";
-        sqlite: "sqlite";
-    }>;
-    scope: z.ZodString;
-    table: z.ZodString;
-}, z.core.$strip>;
-/**
- * Provider-side message-bus boundary — SQS / EventBridge / BullMQ /
- * Kafka / NATS. Producer `interaction(class: "message-send")` effects
- * pair against these via `(messageBus, channel)`.
- *
- * The `channel` string is per-bus. SQS keys it on the single queue
- * identity (CFN logical id / env-var name). EventBridge carries a
- * two-part identity — the event bus AND the DetailType a rule matches —
- * encoded as `"<bus>#<detailType>"`, because one bus multiplexes many
- * event types and a rule subscribes to a subset. See
- * `@suss/framework-aws-eventbridge` for the producer-side scheme and
- * `@suss/contract-cloudformation`'s messageBus reader for the
- * consumer/provider-side scheme.
- */
-declare const MessageBusSemanticsSchema: z.ZodObject<{
-    name: z.ZodLiteral<"message-bus">;
-    messageBus: z.ZodEnum<{
-        sqs: "sqs";
-        eventbridge: "eventbridge";
-        bullmq: "bullmq";
-        kafka: "kafka";
-        nats: "nats";
-    }>;
-    channel: z.ZodString;
-}, z.core.$strip>;
-declare const SemanticsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    name: z.ZodLiteral<"rest">;
-    method: z.ZodString;
-    path: z.ZodString;
-    declaredResponses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-}, z.core.$strip>, z.ZodObject<{
-    name: z.ZodLiteral<"function-call">;
-    module: z.ZodOptional<z.ZodString>;
-    exportName: z.ZodOptional<z.ZodString>;
-    package: z.ZodOptional<z.ZodString>;
-    exportPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>, z.ZodObject<{
-    name: z.ZodLiteral<"graphql-resolver">;
-    typeName: z.ZodString;
-    fieldName: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    name: z.ZodLiteral<"graphql-operation">;
-    operationName: z.ZodOptional<z.ZodString>;
-    operationType: z.ZodEnum<{
-        query: "query";
-        mutation: "mutation";
-        subscription: "subscription";
-    }>;
-}, z.core.$strip>, z.ZodObject<{
-    deploymentTarget: z.ZodEnum<{
-        lambda: "lambda";
-        "ecs-task": "ecs-task";
-        container: "container";
-        "k8s-deployment": "k8s-deployment";
-    }>;
-    instanceName: z.ZodString;
-    name: z.ZodLiteral<"runtime-config">;
-}, z.core.$strip>, z.ZodObject<{
-    name: z.ZodLiteral<"storage-relational">;
-    storageSystem: z.ZodEnum<{
-        postgres: "postgres";
-        mysql: "mysql";
-        sqlite: "sqlite";
-    }>;
-    scope: z.ZodString;
-    table: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    name: z.ZodLiteral<"message-bus">;
-    messageBus: z.ZodEnum<{
-        sqs: "sqs";
-        eventbridge: "eventbridge";
-        bullmq: "bullmq";
-        kafka: "kafka";
-        nats: "nats";
-    }>;
-    channel: z.ZodString;
-}, z.core.$strip>], "name">;
-declare const BoundaryBindingSchema: z.ZodObject<{
-    transport: z.ZodString;
-    semantics: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        name: z.ZodLiteral<"rest">;
-        method: z.ZodString;
-        path: z.ZodString;
-        declaredResponses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    }, z.core.$strip>, z.ZodObject<{
-        name: z.ZodLiteral<"function-call">;
-        module: z.ZodOptional<z.ZodString>;
-        exportName: z.ZodOptional<z.ZodString>;
-        package: z.ZodOptional<z.ZodString>;
-        exportPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
-        name: z.ZodLiteral<"graphql-resolver">;
-        typeName: z.ZodString;
-        fieldName: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        name: z.ZodLiteral<"graphql-operation">;
-        operationName: z.ZodOptional<z.ZodString>;
-        operationType: z.ZodEnum<{
-            query: "query";
-            mutation: "mutation";
-            subscription: "subscription";
-        }>;
-    }, z.core.$strip>, z.ZodObject<{
-        deploymentTarget: z.ZodEnum<{
-            lambda: "lambda";
-            "ecs-task": "ecs-task";
-            container: "container";
-            "k8s-deployment": "k8s-deployment";
-        }>;
-        instanceName: z.ZodString;
-        name: z.ZodLiteral<"runtime-config">;
-    }, z.core.$strip>, z.ZodObject<{
-        name: z.ZodLiteral<"storage-relational">;
-        storageSystem: z.ZodEnum<{
-            postgres: "postgres";
-            mysql: "mysql";
-            sqlite: "sqlite";
-        }>;
-        scope: z.ZodString;
-        table: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        name: z.ZodLiteral<"message-bus">;
-        messageBus: z.ZodEnum<{
-            sqs: "sqs";
-            eventbridge: "eventbridge";
-            bullmq: "bullmq";
-            kafka: "kafka";
-            nats: "nats";
-        }>;
-        channel: z.ZodString;
-    }, z.core.$strip>], "name">;
-    recognition: z.ZodString;
-}, z.core.$strip>;
-type TypeShape = {
-    type: "record";
-    properties: Record<string, TypeShape>;
-    spreads?: Array<{
-        sourceText: string;
-    }> | undefined;
-} | {
-    type: "dictionary";
-    values: TypeShape;
-} | {
-    type: "array";
-    items: TypeShape;
-} | {
-    type: "literal";
-    value: string | number | boolean;
-    raw?: string | undefined;
-} | {
-    type: "text";
-} | {
-    type: "integer";
-} | {
-    type: "number";
-} | {
-    type: "boolean";
-} | {
-    type: "null";
-} | {
-    type: "undefined";
-} | {
-    type: "union";
-    variants: TypeShape[];
-} | {
-    type: "ref";
-    name: string;
-    /**
-     * Where this type is written down, when it is. The key into the
-     * summary's table of definitions.
-     *
-     * A name does not identify a type. Every instantiation of one
-     * generic reports the generic's own name and file, so `Omit<User,
-     * "secret">` and `Omit<Order, "total">` are both `Omit`, and a
-     * table keyed on that hands the second one the first one's
-     * fields. This is built from what the type actually is.
-     */
-    def?: string | undefined;
-    /**
-     * The file that declares this type, when the project declares it.
-     * Absent for a name the language or a dependency owns, which means
-     * the same thing everywhere.
-     *
-     * A name on its own does not identify a type. Two modules each
-     * declaring a `User` produce the same ref, and a checker comparing
-     * them has nothing to go on. This is what tells them apart.
-     */
-    from?: string | undefined;
-} | {
-    type: "unknown";
-};
-/**
- * How a table of definitions names the type a ref points at.
- *
- * A ref carries the name and the file that declares it, and that pair
- * already identifies the type, so a table keyed on it needs nothing new
- * on the ref. A name the language or a dependency owns has no file and
- * keys on the name alone.
- */
-declare function typeDefinitionKey(ref: {
-    def?: string | undefined;
-}): string | null;
-declare const TypeShapeSchema: z.ZodType<TypeShape>;
-/**
- * A shape with the definitions it names put back into it.
- *
- * Comparing two shapes means comparing their structure, and a ref has
- * none. Rather than teach every comparison to look in a table, the
- * table goes back into the shape once, and everything downstream reads
- * what it always read.
- *
- * Putting a definition back is a substitution rather than a level of
- * nesting, so it does not spend depth. Counting it did: a type six
- * deep came back three deep, and a consumer reading a field past that
- * point was told the provider did not have it. What stops a type that
- * names itself is the set of names already being put back on this
- * path, which is how the shape walk guards its own cycles.
- */
-declare function withDefinitionsInlined(shape: TypeShape, definitions: Record<string, TypeShape> | undefined, depth?: number, inProgress?: ReadonlySet<string>): TypeShape;
-
-export { BoundaryBindingSchema, ConfidenceInfoSchema, ConfidenceLevelSchema, ConfidenceSourceSchema, CorroborationSchema, DeployableUnitSchema, FunctionCallSemanticsSchema, GraphqlOperationSemanticsSchema, GraphqlResolverSemanticsSchema, MessageBusSemanticsSchema, RestSemanticsSchema, RuntimeConfigSemanticsSchema, SemanticsSchema, SourceLocationSchema, StorageRelationalSemanticsSchema, type TypeShape, TypeShapeSchema, typeDefinitionKey, withDefinitionsInlined };
+import 'zod';
+export { B as BoundaryBindingSchema, C as ConfidenceInfoSchema, a as ConfidenceLevelSchema, b as ConfidenceSourceSchema, c as CorroborationSchema, e as DeployableUnitSchema, f as FunctionCallSemanticsSchema, g as GraphqlOperationSemanticsSchema, i as GraphqlResolverSemanticsSchema, k as MessageBusSemanticsSchema, l as RestSemanticsSchema, n as RuntimeConfigSemanticsSchema, o as SemanticsSchema, d as SourceLocationSchema, q as StorageRelationalSemanticsSchema, T as TypeShape, r as TypeShapeSchema, w as typeDefinitionKey, x as withDefinitionsInlined } from './schemas-BWvfkxSH.js';

package/dist/schemas.js

@@ -17,7 +17,7 @@ import {
   TypeShapeSchema,
   typeDefinitionKey,
   withDefinitionsInlined
-} from "./chunk-L4XGOS3I.js";
+} from "./chunk-5KE7OWN3.js";
 export {
   BoundaryBindingSchema,
   ConfidenceInfoSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/ir-core",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "description": "Shared IR primitives for suss — type shapes, boundary bindings, source locations, and confidence. Imported by both @suss/behavioral-ir and @suss/intent-ir so neither depends on the other.",
   "keywords": [

package/dist/chunk-L4XGOS3I.js

@@ -1,237 +0,0 @@
-// src/schemas.ts
-import { z } from "zod";
-var ConfidenceSourceSchema = z.enum([
-  "inferred_static",
-  "inferred_ai",
-  "declared",
-  "derived"
-]);
-var ConfidenceLevelSchema = z.enum(["high", "medium", "low"]);
-var CorroborationSchema = z.object({
-  outcome: z.enum(["observed", "refuted", "untested"]),
-  /** Executions that produced a verdict for this claim. */
-  runs: z.number(),
-  /** Present when refuted: the input and observation that disagreed. */
-  counterexample: z.unknown().optional(),
-  /** Present when untested: why no verdict was reachable. */
-  reason: z.string().optional()
-});
-var ConfidenceInfoSchema = z.object({
-  source: ConfidenceSourceSchema,
-  level: ConfidenceLevelSchema,
-  corroboration: CorroborationSchema.optional()
-});
-var SourceLocationSchema = z.object({
-  file: z.string(),
-  range: z.object({ start: z.number(), end: z.number() }),
-  exportName: z.string().nullable(),
-  /**
-   * What the extract was pointed at, as that project calls itself.
-   *
-   * A path is relative to wherever the extract ran, so two services in
-   * one repository both say `src/handlers.ts` and merging their
-   * summaries puts them on top of each other. This is what tells them
-   * apart, and what a reader groups by.
-   */
-  workspace: z.string().optional()
-});
-var RestSemanticsSchema = z.object({
-  name: z.literal("rest"),
-  /** Uppercase HTTP method ("GET", "POST", …). */
-  method: z.string(),
-  /** Normalized route path ("/users/{id}"). */
-  path: z.string(),
-  /**
-   * Status codes the producing source explicitly declared (OpenAPI
-   * responses, CFN MethodResponses, ts-rest router statuses). Kept here
-   * so the pairing layer can still see them without unwrapping metadata.
-   * Empty / absent for inferred sources.
-   */
-  declaredResponses: z.array(z.number()).optional()
-});
-var FunctionCallSemanticsSchema = z.object({
-  name: z.literal("function-call"),
-  /**
-   * Optional module identifier for cross-unit references
-   * (e.g. `"./components/Button"` for a React component, or the TS
-   * module path for a bare function export). Packs that don't do
-   * cross-module pairing can leave it unset.
-   */
-  module: z.string().optional(),
-  /** Named export within the module, when applicable. */
-  exportName: z.string().optional(),
-  /**
-   * Package name (as written in `package.json`) when this identity
-   * refers to a public package export — e.g. `"@suss/behavioral-ir"`.
-   * Set alongside `exportPath` by packs that resolve a package's
-   * public surface (the `packageExports` discovery variant). Distinct
-   * from `module`, which is a repo-relative module path for
-   * intra-repo pairing.
-   */
-  package: z.string().optional(),
-  /**
-   * Path to the exported binding within the package, starting with
-   * the sub-path key when one is used. Examples:
-   *   `["parseSummary"]`              — root export
-   *   `["schemas", "BoundaryBindingSchema"]` — sub-path `./schemas`
-   *
-   * The first segment is the sub-path without the leading `./`
-   * (`"."` → omitted). The last segment is the exported name.
-   */
-  exportPath: z.array(z.string()).optional()
-});
-var GraphqlResolverSemanticsSchema = z.object({
-  name: z.literal("graphql-resolver"),
-  /** GraphQL type the resolver attaches to: "Query", "Mutation", "Subscription", or an object-type name. */
-  typeName: z.string(),
-  /** Field name on that type. */
-  fieldName: z.string()
-});
-var GraphqlOperationSemanticsSchema = z.object({
-  name: z.literal("graphql-operation"),
-  /** Optional operation name — anonymous queries / mutations leave this unset. */
-  operationName: z.string().optional(),
-  operationType: z.enum(["query", "mutation", "subscription"])
-});
-var DeployableUnitSchema = z.object({
-  deploymentTarget: z.enum([
-    "lambda",
-    "ecs-task",
-    "container",
-    "k8s-deployment"
-  ]),
-  // An empty name would agree with every other empty name, so a unit
-  // that names nothing has to leave the field off instead.
-  instanceName: z.string().min(1)
-});
-var RuntimeConfigSemanticsSchema = DeployableUnitSchema.extend({
-  name: z.literal("runtime-config")
-});
-var StorageRelationalSemanticsSchema = z.object({
-  name: z.literal("storage-relational"),
-  storageSystem: z.enum(["postgres", "mysql", "sqlite"]),
-  /**
-   * ORM / driver scope. Defaults to `"default"` for single-database
-   * setups; monorepos with multiple schemas use distinct values.
-   */
-  scope: z.string(),
-  /** Table / model name as declared in the schema. */
-  table: z.string()
-});
-var MessageBusSemanticsSchema = z.object({
-  name: z.literal("message-bus"),
-  messageBus: z.enum(["sqs", "eventbridge", "bullmq", "kafka", "nats"]),
-  /** Stable channel identifier — CFN logical id, queue/topic name, subject pattern, `bus#detailType`. */
-  channel: z.string()
-});
-var SemanticsSchema = z.discriminatedUnion("name", [
-  RestSemanticsSchema,
-  FunctionCallSemanticsSchema,
-  GraphqlResolverSemanticsSchema,
-  GraphqlOperationSemanticsSchema,
-  RuntimeConfigSemanticsSchema,
-  StorageRelationalSemanticsSchema,
-  MessageBusSemanticsSchema
-]);
-var BoundaryBindingSchema = z.object({
-  transport: z.string(),
-  semantics: SemanticsSchema,
-  recognition: z.string()
-});
-function typeDefinitionKey(ref) {
-  return ref.def ?? null;
-}
-var TypeShapeSchema = z.lazy(
-  () => z.discriminatedUnion("type", [
-    z.object({
-      type: z.literal("record"),
-      properties: z.record(z.string(), TypeShapeSchema),
-      spreads: z.array(z.object({ sourceText: z.string() })).optional()
-    }),
-    z.object({ type: z.literal("dictionary"), values: TypeShapeSchema }),
-    z.object({ type: z.literal("array"), items: TypeShapeSchema }),
-    z.object({
-      type: z.literal("literal"),
-      value: z.union([z.string(), z.number(), z.boolean()]),
-      raw: z.string().optional()
-    }),
-    z.object({ type: z.literal("text") }),
-    z.object({ type: z.literal("integer") }),
-    z.object({ type: z.literal("number") }),
-    z.object({ type: z.literal("boolean") }),
-    z.object({ type: z.literal("null") }),
-    z.object({ type: z.literal("undefined") }),
-    z.object({
-      type: z.literal("union"),
-      variants: z.array(TypeShapeSchema)
-    }),
-    z.object({
-      type: z.literal("ref"),
-      name: z.string(),
-      from: z.string().optional(),
-      def: z.string().optional()
-    }),
-    z.object({ type: z.literal("unknown") })
-  ])
-);
-var MAX_DEFINITION_DEPTH = 6;
-function withDefinitionsInlined(shape, definitions, depth = 0, inProgress = /* @__PURE__ */ new Set()) {
-  if (definitions === void 0 || depth >= MAX_DEFINITION_DEPTH) {
-    return shape;
-  }
-  const deeper = (inner) => withDefinitionsInlined(inner, definitions, depth + 1, inProgress);
-  if (shape.type === "ref") {
-    const key = typeDefinitionKey(shape);
-    if (key === null) {
-      return shape;
-    }
-    const defined = definitions[key];
-    if (defined === void 0 || inProgress.has(key)) {
-      return shape;
-    }
-    return withDefinitionsInlined(
-      defined,
-      definitions,
-      depth,
-      /* @__PURE__ */ new Set([...inProgress, key])
-    );
-  }
-  if (shape.type === "record") {
-    const properties = {};
-    for (const [name, value] of Object.entries(shape.properties)) {
-      properties[name] = deeper(value);
-    }
-    return { ...shape, properties };
-  }
-  if (shape.type === "array") {
-    return { ...shape, items: deeper(shape.items) };
-  }
-  if (shape.type === "dictionary") {
-    return { ...shape, values: deeper(shape.values) };
-  }
-  if (shape.type === "union") {
-    return { ...shape, variants: shape.variants.map(deeper) };
-  }
-  return shape;
-}
-
-export {
-  ConfidenceSourceSchema,
-  ConfidenceLevelSchema,
-  CorroborationSchema,
-  ConfidenceInfoSchema,
-  SourceLocationSchema,
-  RestSemanticsSchema,
-  FunctionCallSemanticsSchema,
-  GraphqlResolverSemanticsSchema,
-  GraphqlOperationSemanticsSchema,
-  DeployableUnitSchema,
-  RuntimeConfigSemanticsSchema,
-  StorageRelationalSemanticsSchema,
-  MessageBusSemanticsSchema,
-  SemanticsSchema,
-  BoundaryBindingSchema,
-  typeDefinitionKey,
-  TypeShapeSchema,
-  withDefinitionsInlined
-};