@takeshape/schema 11.52.0 → 11.56.1

package/dist/__tests__/workflows.test.d.ts

@@ -0,0 +1,3 @@
+import type { Workflow } from '../project-schema/index.ts';
+export declare const simpleWorkflow: Workflow;
+export declare const complexWorkflow: Workflow;

package/dist/__tests__/workflows.test.js

@@ -0,0 +1,149 @@
+import postSchemaJson from '@/examples/latest/post-schema.json';
+import { expect, test } from 'vitest';
+import { applyDefaultsToSchema } from "../schema-util.js";
+import { defaultWorkflow, findWorkflowStep, getLiveStepKeys, getStatusField, getWorkflow, getWorkflowStepKeys, statusFallback } from "../workflows.js";
+const postSchema = applyDefaultsToSchema(postSchemaJson);
+test('getStatusFieldV3', () => {
+    const shape = {
+        name: 'post',
+        workflow: 'default',
+        title: 'post',
+        id: 'post',
+        schema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string' },
+                body: { type: 'string' }
+            },
+            required: ['title', 'body']
+        }
+    };
+    expect(getStatusField({ default: defaultWorkflow }, shape)).toEqual({
+        type: 'string',
+        '@workflow': 'default',
+        title: 'Status'
+    });
+});
+test('getWorkflow', () => {
+    expect(getWorkflow(postSchema, '<postContentTypeId>')).toEqual(defaultWorkflow);
+});
+export const simpleWorkflow = {
+    name: 'simple',
+    title: 'Simple',
+    steps: [
+        {
+            name: 'live',
+            title: 'Live',
+            key: 'ByAgr-BZ8',
+            color: '#5cd79b',
+            live: true
+        }
+    ]
+};
+export const complexWorkflow = {
+    name: 'complex',
+    title: 'Complex',
+    steps: [
+        {
+            name: 'draft',
+            title: 'Draft',
+            key: 'r1uCfi4ZL',
+            color: '#bdbdbd',
+            live: false
+        },
+        {
+            name: 'artPhoto',
+            title: 'Art/Photo',
+            key: 'rkhRGs4WL',
+            color: '#5cd79b',
+            live: false
+        },
+        {
+            name: 'legal',
+            title: 'Legal',
+            key: 'SJtxS-rWI',
+            color: '#5cd79b',
+            live: false
+        },
+        {
+            name: 'finalReview',
+            title: 'Final Review',
+            key: 'B1sxHZBZI',
+            color: '#5cd79b',
+            live: false
+        },
+        {
+            name: 'published',
+            title: 'Published',
+            key: 'Hk2xBZSbI',
+            color: '#5cd79b',
+            live: true
+        },
+        {
+            name: 'homepage',
+            title: 'Homepage',
+            key: 'SypgH-S-8',
+            color: '#5cd79b',
+            live: true
+        },
+        {
+            name: 'retired',
+            title: 'Retired',
+            key: 'ByAgr-BZ8',
+            color: '#5cd79b',
+            live: false
+        }
+    ]
+};
+test('findWorkflowStep', () => {
+    expect(findWorkflowStep(complexWorkflow, 'Hk2xBZSbI')).toEqual({
+        index: 4,
+        step: complexWorkflow.steps[4]
+    });
+    expect(findWorkflowStep(complexWorkflow, 'bogus')).toBe(undefined);
+});
+test('statusFallback', () => {
+    expect(statusFallback(defaultWorkflow, true)).toMatchObject({
+        name: 'enabled'
+    });
+    expect(statusFallback(defaultWorkflow, false)).toMatchObject({
+        name: 'disabled'
+    });
+    expect(statusFallback(simpleWorkflow, true)).toMatchObject({ name: 'live' });
+    expect(statusFallback(simpleWorkflow, false)).toMatchObject({ name: 'live' });
+    expect(statusFallback(complexWorkflow, true)).toMatchObject({
+        name: 'published'
+    });
+    expect(statusFallback(complexWorkflow, false)).toMatchObject({
+        name: 'draft'
+    });
+});
+const allKeys = complexWorkflow.steps.map((step) => step.key);
+test('getWorkflowStepKeys - gte', () => {
+    const filteredKeys = getWorkflowStepKeys(complexWorkflow, 'B1sxHZBZI', 'gte');
+    expect(filteredKeys).toEqual(allKeys.slice(3, 7));
+    expect(filteredKeys.includes('B1sxHZBZI')).toBe(true);
+});
+test('getWorkflowStepKeys - gt', () => {
+    expect(getWorkflowStepKeys(complexWorkflow, 'B1sxHZBZI', 'gt')).toEqual(allKeys.slice(4, 7));
+});
+test('getWorkflowStepKeys - lte', () => {
+    const filteredKeys = getWorkflowStepKeys(complexWorkflow, 'B1sxHZBZI', 'lte');
+    expect(filteredKeys).toEqual(allKeys.slice(0, 4));
+    expect(filteredKeys.includes('B1sxHZBZI')).toBe(true);
+});
+test('getWorkflowStepKeys - lt', () => {
+    expect(getWorkflowStepKeys(complexWorkflow, 'B1sxHZBZI', 'lt')).toEqual(allKeys.slice(0, 3));
+});
+test('getWorkflowStepKeys - eq', () => {
+    expect(getWorkflowStepKeys(complexWorkflow, 'B1sxHZBZI', 'eq')).toEqual(['B1sxHZBZI']);
+});
+test('getWorkflowStepKeys - in', () => {
+    expect(getWorkflowStepKeys(complexWorkflow, 'B1sxHZBZI', 'in')).toEqual(['B1sxHZBZI']);
+});
+test('getWorkflowStepKeys - step not found', () => {
+    expect(() => getWorkflowStepKeys(complexWorkflow, 'bogus', 'lt')).toThrowErrorMatchingInlineSnapshot(`[Error: Cannot find step "bogus" in workflow "Complex"]`);
+});
+test('getLiveStepKeys', () => {
+    expect(getLiveStepKeys(complexWorkflow)).toEqual(allKeys.slice(4, 6));
+});

package/dist/agents.d.ts

@@ -0,0 +1,14 @@
+import type { AgentAPIArgument, AgentJSON, Args, ProjectSchemaJSON } from './project-schema/index.ts';
+export declare const END_AGENT_EXECUTION = "endAgentExecution";
+export declare const BUILT_IN_CHAT_ARGS: AgentAPIArgument[];
+export declare const BUILT_IN_CHAT_ARG_NAMES: string[];
+export type AgentEndTransition = {
+    type: 'done' | 'progress';
+    originStateId: string;
+};
+export declare const getAgentEndTransitions: (agent: AgentJSON, includeSuspend?: boolean) => AgentEndTransition[];
+export declare const getAgentEndStates: (agent: AgentJSON, includeSuspend?: boolean) => Set<string>;
+export declare const getInspectAgentSessionQueryName: (agentName: string) => string;
+export declare const removeBuiltInArgs: (args: AgentAPIArgument[]) => AgentAPIArgument[];
+export declare const createArgs: (agent: AgentJSON) => Args | undefined;
+export declare function addAiQueries(projectSchema: ProjectSchemaJSON): ProjectSchemaJSON;

package/dist/auth-schemas.d.ts

@@ -0,0 +1,125 @@
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+/**
+ * A role import document is an array of role
+ *
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "RoleImport".
+ */
+export type RoleImport = RoleInput[];
+export interface AuthSchemas {
+    [k: string]: any;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "Condition".
+ */
+export interface Condition {
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "Statement".
+ */
+export interface Statement {
+    Effect?: 'Allow' | 'Deny';
+    Sid?: string;
+    Action?: string[];
+    NotAction?: string[];
+    Resource?: string[];
+    NotResource?: string[];
+    Principal?: {
+        AWS?: string[];
+        Service?: string[];
+    };
+    Condition?: Condition;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "AccessPolicyDocument".
+ */
+export interface AccessPolicyDocument {
+    Version: string;
+    Statement: Statement[];
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "ApiKey".
+ */
+export interface ApiKey {
+    projectId: string;
+    name: string;
+    role?: string;
+    permissions?: AccessPolicyDocument;
+    lastUsed?: string;
+    apiKey?: string;
+    id: string;
+    delinquent?: boolean;
+    apiRateLimit?: number;
+    deactivated?: number;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "UserPermission".
+ */
+export interface UserPermission {
+    projectId: string;
+    userId: string;
+    role: string;
+    permissions?: AccessPolicyDocument;
+    created?: number;
+    updated?: number;
+    deactivated?: number;
+    delinquent?: boolean;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "Role".
+ */
+export interface Role {
+    projectId: string;
+    name: string;
+    conditions?: Condition;
+    permissions: AccessPolicyDocument;
+    builtIn?: boolean;
+    created?: number;
+    updated?: number;
+}
+/**
+ * Input type for role creation and updates.
+ *
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "RoleInput".
+ */
+export interface RoleInput {
+    projectId?: string;
+    name: string;
+    conditions?: Condition;
+    permissions: AccessPolicyDocument;
+    builtIn?: boolean;
+    created?: number;
+    updated?: number;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "User".
+ */
+export interface User {
+    id: string;
+    email: string;
+    fullName: string;
+    created: number;
+    updated: number;
+    firstTime: boolean;
+    avatarPath?: string;
+    intercomHash?: string;
+    googleUserId?: string;
+    comcastId?: string;
+    token?: string;
+    policies?: AccessPolicyDocument[];
+    preferences?: {
+        [k: string]: any;
+    };
+}

package/dist/builtin-schema.d.ts

@@ -0,0 +1,8 @@
+import type { FormMap, ShapeJSON, ShapeMap } from './project-schema/index.ts';
+import type { Content } from './types/index.ts';
+export declare function isAsset(content: Content): boolean;
+export declare function getAssetS3Path(content: Content): string | undefined;
+export declare function setAssetS3Path(content: Content, path: string): void;
+export declare const jsonShape: ShapeJSON;
+export declare const builtInShapes: ShapeMap;
+export declare const builtInForms: FormMap;

package/dist/content-schema-transform.d.ts

@@ -0,0 +1,35 @@
+import type { ProjectSchemaJSON, PropertySchema, ShapeJSON } from './project-schema/index.ts';
+import type { ContentTransform, KeyTransform, PropertyTransform, PropertyTransformMap, SchemaType, SourceKeyTransform } from './types/index.ts';
+export declare function getType(schema: Pick<PropertySchema, 'type'>): SchemaType;
+export declare function preferKey(name: string, schema: PropertySchema): string;
+/**
+ * A key transform to select the field name
+ */
+export declare const preferName: KeyTransform;
+export declare function preferSourceKey(name: string, schema: PropertySchema): string[];
+export declare function findTransforms(pluginMap: PropertyTransformMap | undefined, schema: PropertySchema, name: string, shape?: ShapeJSON): PropertyTransform | undefined;
+export type Accumulator<T = unknown> = {
+    accumulate(value: unknown, schema: PropertySchema, name: string): void;
+    getResults(): T;
+};
+export type ContentTransformParams = {
+    transforms?: PropertyTransformMap;
+    accumulators?: Accumulator[];
+    projectSchema: ProjectSchemaJSON;
+    keyTransform?: KeyTransform;
+    sourceKeyTransform?: SourceKeyTransform;
+    passThrough?: boolean;
+    allowNullObjects?: boolean;
+};
+export declare function getContentTransform({ transforms, accumulators, keyTransform, sourceKeyTransform, passThrough, allowNullObjects, projectSchema }: ContentTransformParams): ContentTransform;
+export type PropertyInfo = {
+    schema: PropertySchema;
+    key: string;
+    isRequired: boolean;
+};
+export type GetPropertyInfoContext = {
+    projectSchema: ProjectSchemaJSON;
+    transforms?: PropertyTransformMap;
+    keyTransform?: KeyTransform;
+};
+export declare function getPropertyInfo(context: GetPropertyInfoContext, schema: PropertySchema, path: string): PropertyInfo[];

package/dist/content-schema-transform.js

@@ -0,0 +1,162 @@
+import difference from 'lodash/difference.js';
+import forEach from 'lodash/forEach.js';
+import get from 'lodash/get.js';
+import pick from 'lodash/pick.js';
+import { dereferenceSchema, getRefShapeName } from "./refs.js";
+import { getStorageKey } from "./schema-util.js";
+import { isArraySchema, isObjectSchema } from "./types/utils.js";
+import { enumerateOneOfKeys, isUnionSchema } from "./unions.js";
+const typeCache = new WeakMap();
+export function getType(schema) {
+    let type = typeCache.get(schema);
+    if (type) {
+        return type;
+    }
+    type = schema.type;
+    // Handle nullable types for example: ['object', 'null']
+    if (Array.isArray(type)) {
+        const filtered = type.filter((name) => name !== 'null');
+        if (!filtered.length) {
+            throw new Error('Invalid schema');
+        }
+        type = filtered[0];
+    }
+    typeCache.set(schema, type);
+    return type;
+}
+function ensureArray(value) {
+    return Array.isArray(value) ? value : [value];
+}
+export function preferKey(name, schema) {
+    return getStorageKey(schema) ?? name;
+}
+/**
+ * A key transform to select the field name
+ */
+export const preferName = (name) => name;
+function getLocalizedKey(key, locale) {
+    return locale ? `${key}:${locale}` : key;
+}
+function getNonDefaultLocales(projectSchema) {
+    return projectSchema.locales.filter((locale) => locale !== projectSchema.defaultLocale);
+}
+function getLocalizedSourceKeys(keys, locales) {
+    return keys.flatMap((key) => [{ key }, ...locales.map((locale) => ({ key: `${key}:${locale}`, locale }))]);
+}
+export function preferSourceKey(name, schema) {
+    const key = getStorageKey(schema);
+    return key ? [key, name] : [name];
+}
+export function findTransforms(pluginMap, schema, name, shape) {
+    const type = getType(schema);
+    if (pluginMap && (pluginMap[type] ?? pluginMap['*'])) {
+        const plugins = (pluginMap[type] ?? []).concat(pluginMap['*'] ?? []);
+        return plugins.find((plugin) => plugin.filter(schema, name, shape));
+    }
+    return undefined;
+}
+export function getContentTransform({ transforms, accumulators, keyTransform = preferKey, sourceKeyTransform = preferSourceKey, passThrough = true, allowNullObjects = false, projectSchema }) {
+    const nonDefaultLocales = getNonDefaultLocales(projectSchema);
+    const prepare = (schema, obj, name = '') => {
+        const shapeName = getRefShapeName(projectSchema, schema);
+        schema = dereferenceSchema(projectSchema, schema);
+        if (accumulators) {
+            for (const accumulator of accumulators) {
+                accumulator.accumulate(obj, schema, name);
+            }
+        }
+        const shape = shapeName ? projectSchema.shapes[shapeName] : undefined;
+        const transform = findTransforms(transforms, schema, name, shape);
+        if (transform) {
+            const next = (value, schema, name) => prepare(schema, value, name);
+            return transform.process(obj, schema, name, shape, next);
+        }
+        if (obj && isUnionSchema(schema)) {
+            for (const { shapeId, propSchema } of enumerateOneOfKeys(projectSchema, schema.oneOf)) {
+                if (obj._shapeId === shapeId) {
+                    return prepare(propSchema, obj, name);
+                }
+            }
+        }
+        if (obj && isObjectSchema(schema)) {
+            const result = {};
+            const assigned = new Set();
+            forEach(schema.properties, (fieldSchema, name) => {
+                const sourceKeys = ensureArray(sourceKeyTransform(name, fieldSchema, obj));
+                const localizedSourceKeys = getLocalizedSourceKeys(sourceKeys, nonDefaultLocales);
+                for (const { key: sourceKey, locale } of localizedSourceKeys) {
+                    const value = prepare(fieldSchema, get(obj, sourceKey), name);
+                    if (value !== undefined) {
+                        assigned.add(sourceKey);
+                        const transform = findTransforms(transforms, dereferenceSchema(projectSchema, fieldSchema), name);
+                        const getKey = transform?.keyTransform ? transform.keyTransform : keyTransform;
+                        const key = getLocalizedKey(getKey(name, fieldSchema, sourceKey), locale);
+                        result[key] = value;
+                    }
+                }
+            });
+            if (passThrough && obj) {
+                const keys = difference(Object.keys(obj), [...assigned]);
+                if (keys.length) {
+                    Object.assign(result, pick(obj, keys));
+                }
+            }
+            return result;
+        }
+        if (isArraySchema(schema)) {
+            const itemSchema = schema.items;
+            if (Array.isArray(obj)) {
+                return obj.map((item) => prepare(itemSchema, item, name));
+            }
+            if (obj === undefined) {
+                prepare(itemSchema, obj, name);
+            }
+        }
+        if (allowNullObjects && isObjectSchema(schema) && obj === null) {
+            return null;
+        }
+        // Allow properties that have not been transformed
+        return passThrough ? obj : undefined;
+    };
+    return prepare;
+}
+function transformKey(transforms, propSchema, name, transform = preferKey) {
+    const schemaTransform = findTransforms(transforms, propSchema, name);
+    if (schemaTransform?.keyTransform) {
+        transform = schemaTransform.keyTransform;
+    }
+    return transform(name, propSchema);
+}
+export function getPropertyInfo(context, schema, path) {
+    const { projectSchema, transforms, keyTransform } = context;
+    const result = [];
+    const findProperty = (currentSchema, name, rest, path) => {
+        if (isObjectSchema(currentSchema)) {
+            const propSchema = currentSchema.properties[name];
+            const isRequired = currentSchema.required?.includes(name) ?? false;
+            if (!propSchema) {
+                return;
+            }
+            const refSchema = dereferenceSchema(projectSchema, propSchema);
+            const nextPath = path.concat(transformKey(transforms, refSchema, name, keyTransform));
+            if (rest.length) {
+                const [nextName, ...nextRest] = rest;
+                findProperty(refSchema, nextName, nextRest, nextPath);
+            }
+            else {
+                result.push({ schema: refSchema, key: nextPath.join('.'), isRequired });
+            }
+        }
+        else if (isUnionSchema(currentSchema)) {
+            for (const optionSchema of currentSchema.oneOf) {
+                findProperty(dereferenceSchema(projectSchema, optionSchema), name, rest, path);
+            }
+        }
+        else if (isArraySchema(currentSchema)) {
+            findProperty(dereferenceSchema(projectSchema, currentSchema.items), name, rest, path);
+        }
+    };
+    const [first, ...rest] = path.split('.');
+    findProperty(dereferenceSchema(projectSchema, schema), first, rest, []);
+    return result;
+}

package/dist/create-input-schema.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectSchemaJSON, PropertySchema, ShapeSchema } from './project-schema/index.ts';
+export type CreateInputSchemaOptions = {
+    isUpdate?: boolean;
+};
+/**
+ * Convert all output properties in the schema to be input properties,
+ * For an update, remove `required` and `default` fields as well.
+ */
+export declare function createInputSchema<T extends ProjectSchemaJSON | ShapeSchema | PropertySchema>(schema: T, options?: CreateInputSchemaOptions): T;

package/dist/enum.d.ts

@@ -0,0 +1,2 @@
+import type { PropertySchema } from './project-schema/index.ts';
+export declare function isEnumLikeSchema(schema: PropertySchema): boolean;

package/dist/flatten-templates.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectSchemaJSON } from './project-schema/index.ts';
+export declare function flattenTemplates<T extends ProjectSchemaJSON>(projectSchema: T): T;

package/dist/flatten-templates.js

@@ -0,0 +1,20 @@
+import { deepClone } from '@takeshape/util';
+import set from 'lodash/set.js';
+import { refItemToNamespacedShapeName } from "./refs.js";
+import { getAllRefs } from "./schema-util.js";
+import { isValidTemplate, resolveTemplate } from "./template-shapes/index.js";
+export function flattenTemplates(projectSchema) {
+    const templateRefs = getAllRefs(projectSchema, (ref) => Boolean(ref.template));
+    if (!templateRefs.length) {
+        return projectSchema;
+    }
+    const newSchema = deepClone(projectSchema);
+    for (const ref of templateRefs) {
+        if (ref.template && isValidTemplate(ref.template)) {
+            const { shapeName, dependencies } = resolveTemplate(newSchema, ref.template, refItemToNamespacedShapeName(ref));
+            set(newSchema, ref.path, ref.path[ref.path.length - 1] === '@ref' ? `local:${shapeName}` : shapeName);
+            Object.assign(newSchema.shapes, dependencies);
+        }
+    }
+    return newSchema;
+}

package/dist/get-is-leaf.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectSchemaJSON, PropertySchema } from './project-schema/index.ts';
+export type IsLeaf = (key?: string) => boolean;
+export declare function getIsLeaf(projectSchema: ProjectSchemaJSON, shapeSchema: PropertySchema): IsLeaf;

package/dist/get-is-leaf.js

@@ -0,0 +1,56 @@
+import { getType } from "./content-schema-transform.js";
+import { followRef, getRefShapeName } from "./refs.js";
+import { getStorageKey, isBuiltinType } from "./schema-util.js";
+import { isPropertySchemaWithRelationship } from "./types/index.js";
+const scalarTags = new Set(['draftjs']);
+function isLeafTypeV3(projectSchema, propertySchema) {
+    const type = getType(propertySchema);
+    return Boolean(
+    // Must have key
+    getStorageKey(propertySchema) &&
+        // If is not a structure, then is a leaf
+        (!['object', 'array'].includes(type) ||
+            // If is relationship, then is a leaf
+            isPropertySchemaWithRelationship(propertySchema['@output'] ?? propertySchema) ||
+            Boolean(propertySchema['@tag'] && scalarTags.has(propertySchema['@tag'])) ||
+            // If is array, then should not be a synchronized structure
+            (type === 'array' && !propertySchema['@syncLocaleStructure']) ||
+            isBuiltinType(projectSchema, propertySchema)));
+}
+export function getIsLeaf(projectSchema, shapeSchema) {
+    const leafMap = new Set();
+    const shapesSeen = new Set();
+    const collectLeaves = (schema) => {
+        const shapeName = getRefShapeName(projectSchema, schema);
+        schema = shapeName ? followRef(projectSchema, schema) : schema;
+        const key = getStorageKey(schema);
+        if (key && isLeafTypeV3(projectSchema, schema)) {
+            leafMap.add(key);
+        }
+        if (shapeName) {
+            // Skip shapes we have already seen to avoid cycles
+            if (shapesSeen.has(shapeName)) {
+                return;
+            }
+            shapesSeen.add(shapeName);
+        }
+        const combo = schema.oneOf ?? schema.allOf;
+        if (combo) {
+            combo.map(collectLeaves);
+        }
+        else if (schema.properties) {
+            for (const name of Object.keys(schema.properties)) {
+                collectLeaves(schema.properties[name]);
+            }
+        }
+        else if (schema.items) {
+            collectLeaves(schema.items);
+        }
+    };
+    collectLeaves(shapeSchema);
+    return (key) => {
+        // Remove locale suffix
+        key = key ? key.split(':')[0] : key;
+        return Boolean(key && leafMap.has(key));
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+export type { RoleImport, Condition, Statement, AccessPolicyDocument, ApiKey, UserPermission, Role, RoleInput, User } from './auth-schemas.ts';
+export type { ProjectSchemaUpdate } from './migration/types.ts';
+export * from './content-schema-transform.ts';
+export * from './get-is-leaf.ts';
+export * from './project-schema/index.ts';
+export * from './project-schema/migrate.ts';
+export * from './schema-util.ts';
+export * from './template-shapes/index.ts';
+export * from './taxonomies.ts';
+export * from './workflows.ts';
+export * from './api-version.ts';
+export * from './migration/index.ts';
+export * from './validate/validate.ts';
+export * from './validate/errors.ts';
+export * from './builtin-schema.ts';
+export * from './versions.ts';
+export * from './mocks.ts';
+export * from './scalars.ts';
+export * from './refs.ts';
+export * from './unions.ts';
+export * from './enum.ts';
+export * from './patterns.ts';
+export * from './types/transforms.ts';
+export * from './types/types.ts';
+export * from './types/utils.ts';
+export * from './flatten-templates.ts';
+export * from './relationships.ts';
+export * from './create-input-schema.ts';
+export * from './schema-transform.ts';
+export * from './interfaces.ts';
+export * from './agents.ts';
+export * from './services/services.ts';
+export * from './services/util.ts';
+export * from './services/types.ts';
+export * from './util/api-indexing.ts';
+export * from './util/form-config.ts';
+export * from './util/ai-tools.ts';
+export * from './util/detect-cycles.ts';
+export * from './util/find-shape-at-path.ts';
+export * from './util/get-conflicting-properties.ts';
+export * from './util/get-return-shape.ts';
+export * from './util/has-arg.ts';
+export * from './util/merge.ts';
+export * from './util/patch-schema.ts';
+export * from './util/shapes.ts';
+export * from './constants.ts';
+export * from './runtime-schema.ts';
+export * from './service-dependencies.ts';