@resistdesign/voltra 3.0.0-alpha.5 → 3.0.0-alpha.7

package/index.js

@@ -4,15 +4,15 @@ import { QueryCommand, DynamoDBClient, PutItemCommand, GetItemCommand, UpdateIte
 import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
 import { S3, PutObjectCommand, HeadObjectCommand, CopyObjectCommand, GetObjectCommand, DeleteObjectCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
-import Path5 from 'path';
-import FS, { promises } from 'fs';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { SyntaxKind, isLiteralTypeNode, isStringLiteral, isNumericLiteral, createSourceFile, ScriptTarget } from 'typescript';
 import { v4 } from 'uuid';
+import Path4 from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { createContext, useContext, useRef, useMemo, useCallback, useState, useEffect } from 'react';
 import { jsx } from 'react/jsx-runtime';
 import styled from 'styled-components';
 import YAML from 'yaml';
+import { SyntaxKind } from 'typescript';
+import { promises } from 'fs';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -4049,985 +4049,582 @@ var DATA_ITEM_DB_DRIVER_ERRORS = /* @__PURE__ */ ((DATA_ITEM_DB_DRIVER_ERRORS2)
   return DATA_ITEM_DB_DRIVER_ERRORS2;
 })(DATA_ITEM_DB_DRIVER_ERRORS || {});
 
-// src/common/TypeParsing/index.ts
-var TypeParsing_exports = {};
-__export(TypeParsing_exports, {
-  Constants: () => Constants_exports,
-  TypeInfo: () => TypeInfo_exports,
-  TypeMapping: () => TypeMapping_exports,
-  Validation: () => Validation_exports,
-  getTypeInfoMapFromTypeScript: () => getTypeInfoMapFromTypeScript
-});
-
-// src/common/TypeParsing/TypeMapping.ts
-var TypeMapping_exports = {};
-__export(TypeMapping_exports, {
-  convertASTToMap: () => convertASTToMap
-});
-var convertASTToMap = (node, map = {}, parentName) => {
-  node.forEachChild((child) => {
-    const { kind: childKind } = child;
-    if (childKind === SyntaxKind.ModuleDeclaration) {
-      const moduleNode = child;
-      const { name: moduleName } = moduleNode;
-      const textModuleName = moduleName.getText();
-      const fullModuleName = parentName ? `${parentName}.${textModuleName}` : textModuleName;
-      convertASTToMap(moduleNode, map, fullModuleName);
-    }
-    if (childKind === SyntaxKind.ModuleBlock) {
-      convertASTToMap(child, map, parentName);
-    }
-    if (childKind === SyntaxKind.TypeAliasDeclaration) {
-      const typeAliasDec = child;
-      const {
-        name: { text: typeName }
-      } = typeAliasDec;
-      const fullTypeName = parentName ? `${parentName}.${typeName}` : typeName;
-      map[fullTypeName] = typeAliasDec;
-    }
-  });
-  return map;
-};
-
-// src/common/TypeParsing/ParsingUtils/extractCommentTags.ts
-var TAG_NAME_PATH_DELIMITER = ".";
-var getFlatTagValue = (tagValue) => {
-  if (typeof tagValue === "undefined") {
-    return "";
-  } else if (Array.isArray(tagValue)) {
-    const valueNodeArray = tagValue;
-    const valueList = [];
-    for (let i = 0; i < valueNodeArray.length; i++) {
-      const { text } = valueNodeArray[i];
-      valueList.push(getFlatTagValue(text));
-    }
-    return valueList.join(" ");
-  } else {
-    return `${tagValue}`;
-  }
-};
-var getTagNameAndValue = (tag) => {
-  let name = tag.tagName.text, value = getFlatTagValue(tag.comment);
-  if (value.startsWith(TAG_NAME_PATH_DELIMITER)) {
-    const extendedTagNameEndIndex = value.indexOf(" ");
-    const hasActualValue = extendedTagNameEndIndex !== -1;
-    name += hasActualValue ? value.slice(0, extendedTagNameEndIndex) : value;
-    value = hasActualValue ? value.slice(extendedTagNameEndIndex + 1) : "";
-  }
-  if (value === "") {
-    value = "true";
-  }
-  return {
-    name,
-    value
-  };
-};
-var getObjectWithValueAppliedToPath = (path = [], value, baseObject) => {
-  let baseParentObject = void 0, currentParent = void 0;
-  if (path.length === 0) {
-    baseParentObject = value;
-  } else {
-    for (let i = 0; i < path.length; i++) {
-      const pathPart = path[i];
-      const cleanPathPart = typeof pathPart === "number" ? pathPart : `${typeof pathPart !== "undefined" ? pathPart : ""}`;
-      const isNum = typeof cleanPathPart === "number";
-      let newCurrentParent = void 0;
-      if (i === 0) {
-        if (!baseObject) {
-          baseParentObject = isNum ? [] : {};
-        } else {
-          baseParentObject = isNum ? [...Array.isArray(baseObject) ? baseObject : []] : {
-            ...typeof baseObject === "object" ? baseObject : {}
-          };
-        }
-        currentParent = baseParentObject;
-      }
-      if (i < path.length - 1) {
-        const existingNewCurrentParent = currentParent[cleanPathPart];
-        newCurrentParent = isNum ? [
-          ...Array.isArray(existingNewCurrentParent) ? existingNewCurrentParent : []
-        ] : {
-          ...typeof existingNewCurrentParent === "object" ? existingNewCurrentParent : {}
-        };
-        currentParent[cleanPathPart] = newCurrentParent;
-        currentParent = newCurrentParent;
-      } else {
-        currentParent[cleanPathPart] = value;
-      }
-    }
-  }
-  return baseParentObject;
-};
-var extractCommentTags = (node) => {
-  const jsDocComments = node["jsDoc"];
-  let commentTags = {};
-  if (jsDocComments) {
-    jsDocComments.forEach((jsDoc) => {
-      const tags = jsDoc.tags;
-      if (tags) {
-        tags.forEach((tag) => {
-          const { name: tagName, value: tagValue } = getTagNameAndValue(tag);
-          const potentialJSONValue = getPotentialJSONValue(tagValue);
-          commentTags = getObjectWithValueAppliedToPath(
-            getPathArray(tagName, TAG_NAME_PATH_DELIMITER),
-            potentialJSONValue,
-            commentTags
-          );
-        });
-      }
-    });
-  }
-  return commentTags;
-};
-var extractLiteralValues = (node) => {
-  const literalValues = [];
-  let detectedTypeKeyword;
-  for (const type of node.types) {
-    if (isLiteralTypeNode(type)) {
-      const literal = type.literal;
-      if (isStringLiteral(literal)) {
-        if (!detectedTypeKeyword) detectedTypeKeyword = "string";
-        if (detectedTypeKeyword === "string") {
-          literalValues.push(literal.text);
-        }
-      } else if (isNumericLiteral(literal)) {
-        if (!detectedTypeKeyword) detectedTypeKeyword = "number";
-        if (detectedTypeKeyword === "number") {
-          literalValues.push(Number(literal.text));
-        }
-      } else if (literal.kind === SyntaxKind.TrueKeyword || literal.kind === SyntaxKind.FalseKeyword) {
-        if (!detectedTypeKeyword) detectedTypeKeyword = "boolean";
-        if (detectedTypeKeyword === "boolean") {
-          literalValues.push(literal.kind === SyntaxKind.TrueKeyword);
-        }
-      } else if (literal.kind === SyntaxKind.NullKeyword) {
-        literalValues.push(null);
+// src/api/ORM/drivers/S3FileItemDBDriver/ConfigTypeInfoMap.json
+var ConfigTypeInfoMap_default = {
+  Logger: {
+    fields: {
+      trace: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      debug: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        typeReference: "Trace",
+        tags: {}
+      },
+      info: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        typeReference: "Trace",
+        tags: {}
+      },
+      warn: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        typeReference: "Trace",
+        tags: {}
+      },
+      error: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        typeReference: "Trace",
+        tags: {}
       }
-    } else {
-      return void 0;
-    }
-  }
-  return literalValues.length ? { values: literalValues, type: detectedTypeKeyword } : void 0;
-};
-
-// src/common/TypeParsing/ParsingUtils/checkUnionType.ts
-var checkUnionType = (unionType) => {
-  const extracted = extractLiteralValues(unionType);
-  let typeKeyword = "string";
-  let options;
-  if (extracted) {
-    options = extracted.values;
-    typeKeyword = extracted.type;
-  }
-  return { options: options || [], typeKeyword };
-};
-var getTypeKeyword = (node) => {
-  switch (node.kind) {
-    case SyntaxKind.StringKeyword:
-      return "string";
-    case SyntaxKind.NumberKeyword:
-      return "number";
-    case SyntaxKind.BooleanKeyword:
-      return "boolean";
-    default:
-      return "string";
-  }
-};
-
-// src/common/TypeParsing/ParsingUtils/checkType.ts
-var checkType = (node) => {
-  let typeReference;
-  let isArray = false;
-  let typeKeyword;
-  let options;
-  if (node.kind === SyntaxKind.TypeReference) {
-    typeReference = node.typeName.getText();
-    typeKeyword = "string";
-  } else if (node.kind === SyntaxKind.ArrayType) {
-    isArray = true;
-    const elementType = node.elementType;
-    const {
-      typeReference: elementReference,
-      isArray: elementIsArray,
-      typeKeyword: elementKeyword,
-      options: elementOptions
-    } = checkType(elementType);
-    typeReference = elementReference;
-    isArray = !!elementIsArray;
-    typeKeyword = elementKeyword || "string";
-    options = elementOptions;
-  } else if (node.kind === SyntaxKind.UnionType) {
-    const { types: unionTypes } = node;
-    const { options: unionOptions, typeKeyword: unionTypeKeyword } = checkUnionType(node);
-    options = unionOptions;
-    typeKeyword = unionTypeKeyword;
-    if (!options) {
-      typeKeyword = getTypeKeyword(unionTypes[0]);
-    }
-  } else if (node.kind === SyntaxKind.ParenthesizedType) {
-    const {
-      typeReference: parenthesizedReference,
-      isArray: parenthesizedIsArray,
-      typeKeyword: parenthesizedKeyword,
-      options: parenthesizedOptions
-    } = checkType(node.type);
-    typeReference = parenthesizedReference;
-    isArray = !!parenthesizedIsArray;
-    typeKeyword = parenthesizedKeyword || "string";
-    options = parenthesizedOptions;
-  } else {
-    typeKeyword = getTypeKeyword(node);
-  }
-  return { typeReference, isArray, typeKeyword, options };
-};
-
-// src/common/TypeParsing/ParsingUtils/extractTypeDetails.ts
-var extractTypeDetails = (type) => {
-  const { isArray, typeReference, options, typeKeyword } = checkType(type);
-  return {
-    type: typeKeyword || "string",
-    typeReference,
-    array: !!isArray,
-    options
-  };
-};
-
-// src/common/TypeParsing/ParsingUtils/getTypeInfoField.ts
-var getTypeInfoField = (propertySignature) => {
-  const { type, modifiers } = propertySignature;
-  const {
-    array,
-    typeReference,
-    type: typeKeyword,
-    options
-  } = type ? extractTypeDetails(type) : {
-    array: false,
-    typeReference: void 0,
-    type: "string",
-    options: void 0
-  };
-  const readonly = modifiers ? modifiers.some((modifier) => modifier.kind === SyntaxKind.ReadonlyKeyword) : false;
-  const optional = !!propertySignature.questionToken;
-  let tags = extractCommentTags(propertySignature);
-  if (readonly) {
-    const {
-      deniedOperations,
-      deniedOperations: { CREATE, UPDATE, DELETE } = {}
-    } = tags || {};
-    tags = {
-      ...tags,
-      deniedOperations: {
-        ...deniedOperations,
-        create: CREATE ?? true,
-        update: UPDATE ?? true,
-        delete: DELETE ?? true
+    },
+    tags: {},
+    primaryField: "trace"
+  },
+  Endpoint: {
+    fields: {
+      protocol: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      hostname: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      port: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      path: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      query: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
       }
-    };
-  }
-  return {
-    type: typeKeyword,
-    array,
-    readonly,
-    optional,
-    typeReference,
-    possibleValues: options,
-    tags
-  };
-};
-
-// src/common/TypeParsing/ParsingUtils/getTypeInfo.ts
-var getTypeInfo = (typeLiteral) => {
-  const { members } = typeLiteral;
-  const tags = extractCommentTags(typeLiteral);
-  let fields = {};
-  for (const m of members) {
-    const { name, kind } = m;
-    if (name && kind === SyntaxKind.PropertySignature) {
-      const fieldName = name.getText();
-      const field = getTypeInfoField(m);
-      fields = {
-        ...fields,
-        [fieldName]: field
-      };
-    }
-  }
-  return {
-    fields,
-    tags
-  };
-};
-var getUnionOrIntersectionTypeInfo = (unionType, typeMap) => {
-  const { kind, types } = unionType;
-  const isUnion = kind === SyntaxKind.UnionType;
-  let typeInfo;
-  for (const t of types) {
-    const { kind: kind2 } = t;
-    let nextTypeInfo;
-    if (kind2 === SyntaxKind.TypeReference) {
-      const { typeName } = t;
-      const refNode = typeMap[typeName.getText()];
-      if (refNode) {
-        nextTypeInfo = getTypeInfoFromTypeAlias(refNode, typeMap);
-      }
-    } else if (kind2 === SyntaxKind.TypeLiteral) {
-      nextTypeInfo = getTypeInfo(t);
-    }
-    if (nextTypeInfo) {
-      const {
-        fields: existingFields = {},
-        unionFieldSets: existingFieldSets = []
-      } = typeInfo || {};
-      const { fields: nextFields, unionFieldSets: nextUnionFieldSets = [] } = nextTypeInfo;
-      if (isUnion && nextFields) {
-        const newUnionFieldSet = Object.keys(nextFields);
-        typeInfo = {
-          ...typeInfo,
-          unionFieldSets: [
-            ...existingFieldSets,
-            ...nextUnionFieldSets,
-            newUnionFieldSet
-          ]
-        };
+    },
+    tags: {},
+    primaryField: "protocol"
+  },
+  Properties: {
+    fields: {
+      authSchemes: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
       }
-      typeInfo = {
-        ...typeInfo,
-        fields: {
-          ...existingFields,
-          ...nextFields
-        }
-      };
-    }
-  }
-  return typeInfo;
-};
-
-// src/common/TypeParsing/ParsingUtils/Constants.ts
-var FIELD_FILTERS = {
-  OMIT: "Omit",
-  PICK: "Pick",
-  EXCLUDE: "Exclude"
-};
-var getUnionOrLiteralStringValues = (node) => {
-  let values = [];
-  if (node) {
-    if (node.kind === SyntaxKind.LiteralType) {
-      const { literal } = node;
-      if (literal.kind === SyntaxKind.StringLiteral || literal.kind === SyntaxKind.NumericLiteral) {
-        const { text } = literal;
-        values = [text];
+    },
+    tags: {},
+    primaryField: "authSchemes"
+  },
+  RetryStrategy: {
+    fields: {
+      mode: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      retry: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
       }
-    } else if (node.kind === SyntaxKind.UnionType) {
-      const { types } = node;
-      for (const type of types) {
-        values = [...values, ...getUnionOrLiteralStringValues(type)];
+    },
+    tags: {},
+    primaryField: "mode"
+  },
+  Credentials: {
+    fields: {
+      accessKeyId: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      secretAccessKey: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      sessionToken: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      credentialScope: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      expiration: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
       }
-    }
-  }
-  return values;
-};
-
-// src/common/TypeParsing/ParsingUtils/getTypeInfoFromFieldFilter.ts
-var getTypeInfoFromPickOmitFieldFilters = (typeNameStr, typeRef, typeMap) => {
-  const picking = typeNameStr === FIELD_FILTERS.PICK;
-  const omitTypeKind = typeRef.typeArguments?.[0].kind;
-  let typeInfo;
-  if (omitTypeKind === SyntaxKind.TypeReference && typeRef.typeArguments && typeRef.typeArguments[0].kind === SyntaxKind.TypeReference) {
-    const omitType = typeRef.typeArguments[0];
-    const omitTypeFields = typeRef.typeArguments[1];
-    const omitTypeName = omitType.typeName.getText();
-    const refNode = typeMap[omitTypeName];
-    if (refNode) {
-      const {
-        fields: existingFields = {},
-        unionFieldSets: existingUnionFieldSets,
-        ...typeInfoOther
-      } = getTypeInfoFromTypeAlias(refNode, typeMap) || {};
-      const omitFieldNames = getUnionOrLiteralStringValues(omitTypeFields);
-      const cleanTypeInfoFields = Object.keys(
-        existingFields
-      ).reduce(
-        (acc, key) => {
-          if (acc && (picking && omitFieldNames.includes(key) || !picking && !omitFieldNames.includes(key)) && existingFields[key]) {
-            acc[key] = existingFields[key];
-          }
-          return acc;
-        },
-        {}
-      );
-      const cleanUnionFieldSets = existingUnionFieldSets ? existingUnionFieldSets.map(
-        (fieldSet) => fieldSet.filter(
-          (field) => picking ? omitFieldNames.includes(field) : !omitFieldNames.includes(field)
-        )
-      ) : void 0;
-      typeInfo = {
-        ...typeInfoOther,
-        fields: cleanTypeInfoFields,
-        unionFieldSets: cleanUnionFieldSets
-      };
-    }
-  }
-  return typeInfo;
-};
-var getTypeInfoFromExcludeFieldFilter = (typeNameStr, typeRef, typeMap) => {
-  const baseTypeKind = typeRef.typeArguments?.[0].kind;
-  const excludeTypeKind = typeRef.typeArguments?.[1].kind;
-  let typeInfo;
-  if (baseTypeKind === SyntaxKind.TypeReference && excludeTypeKind === SyntaxKind.TypeReference && typeRef.typeArguments) {
-    const baseType = typeRef.typeArguments[0];
-    const excludeType = typeRef.typeArguments[1];
-    const baseTypeName = baseType.typeName.getText();
-    const excludeTypeName = excludeType.typeName.getText();
-    const refNode = typeMap[baseTypeName];
-    const excludeNode = typeMap[excludeTypeName];
-    if (refNode && excludeNode) {
-      const baseTypeInfo = getTypeInfoFromTypeAlias(refNode, typeMap);
-      const excludeTypeInfo = getTypeInfoFromTypeAlias(excludeNode, typeMap);
-      if (baseTypeInfo && excludeTypeInfo) {
-        const {
-          fields: baseFields = {},
-          unionFieldSets: existingUnionFieldSets
-        } = baseTypeInfo;
-        const { fields: excludeFields = {} } = excludeTypeInfo;
-        const excludeFieldNames = Object.keys(excludeFields);
-        const cleanTypeInfoFields = Object.keys(
-          baseFields
-        ).reduce(
-          (acc, key) => {
-            if (acc && !excludeFieldNames.includes(key) && baseFields[key]) {
-              acc[key] = baseFields[key];
-            }
-            return acc;
-          },
-          {}
-        );
-        const cleanUnionFieldSets = existingUnionFieldSets ? existingUnionFieldSets.map(
-          (fieldSet) => fieldSet.filter((field) => !excludeFieldNames.includes(field))
-        ) : void 0;
-        typeInfo = {
-          ...baseTypeInfo,
-          fields: cleanTypeInfoFields,
-          unionFieldSets: cleanUnionFieldSets
-        };
+    },
+    tags: {},
+    primaryField: "accessKeyId"
+  },
+  Signer: {
+    fields: {
+      sign: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
       }
-    }
-  }
-  return typeInfo;
-};
-var defaultFieldFilterProcessor = (typeNameStr, typeRef, typeMap) => {
-  const refNode = typeNameStr ? typeMap[typeNameStr] : void 0;
-  let typeInfo;
-  if (refNode) {
-    typeInfo = getTypeInfoFromTypeAlias(refNode, typeMap);
-  }
-  return typeInfo;
-};
-var FIELD_FILTER_PROCESSORS = {
-  [FIELD_FILTERS.PICK]: getTypeInfoFromPickOmitFieldFilters,
-  [FIELD_FILTERS.OMIT]: getTypeInfoFromPickOmitFieldFilters,
-  [FIELD_FILTERS.EXCLUDE]: getTypeInfoFromExcludeFieldFilter
-};
-var getTypeInfoFromFieldFilter = (typeNameStr, typeRef, typeMap) => {
-  const processor = typeNameStr ? FIELD_FILTER_PROCESSORS[typeNameStr] : void 0;
-  return processor ? processor(typeNameStr, typeRef, typeMap) : defaultFieldFilterProcessor(typeNameStr, typeRef, typeMap);
-};
-
-// src/common/TypeParsing/ParsingUtils/getTypeInfoFromAliasType.ts
-var getTypeInfoFromTypeLiteral = (type) => getTypeInfo(type);
-var getTypeInfoFromUnionOrIntersectionType = (type, typeMap) => getUnionOrIntersectionTypeInfo(type, typeMap);
-var getTypeInfoFromTypeReference = (type, typeMap) => {
-  const typeRef = type;
-  const { typeName } = typeRef;
-  const typeNameStr = typeName.getText();
-  return getTypeInfoFromFieldFilter(typeNameStr, typeRef, typeMap);
-};
-var ALIAS_TYPE_PROCESSORS = {
-  [SyntaxKind.TypeLiteral]: getTypeInfoFromTypeLiteral,
-  [SyntaxKind.UnionType]: getTypeInfoFromUnionOrIntersectionType,
-  [SyntaxKind.IntersectionType]: getTypeInfoFromUnionOrIntersectionType,
-  [SyntaxKind.TypeReference]: getTypeInfoFromTypeReference
-};
-var getTypeInfoFromAliasType = (type, typeMap) => {
-  const { kind } = type;
-  const processor = ALIAS_TYPE_PROCESSORS[kind];
-  const typeInfo = processor ? processor(type, typeMap) : void 0;
-  return typeInfo;
-};
-
-// src/common/TypeParsing/ParsingUtils/getTypeInfoFromTypeAlias.ts
-var getTypeInfoFromTypeAlias = (typeAliasDec, typeMap) => {
-  const { type } = typeAliasDec;
-  const tags = extractCommentTags(typeAliasDec);
-  const typeInfo = getTypeInfoFromAliasType(type, typeMap);
-  return typeInfo ? {
-    ...typeInfo,
-    tags: {
-      ...tags,
-      ...typeInfo.tags
-    }
-  } : void 0;
-};
-
-// src/common/TypeParsing/ParsingUtils/getPrimaryFieldForTypeInfo.ts
-var getPrimaryFieldForTypeInfo = (typeInfo) => {
-  const { fields } = typeInfo;
-  let primaryField = void 0, primaryFieldReadDenied = false;
-  for (const fieldName in fields) {
-    const field = fields[fieldName];
-    const {
-      tags: {
-        primaryField: isPrimaryField = false,
-        deniedOperations: { READ: readDenied = false } = {}
-      } = {}
-    } = field;
-    if (isPrimaryField || !primaryField) {
-      primaryField = fieldName;
-      primaryFieldReadDenied = readDenied;
-    }
-    if (isPrimaryField) {
-      break;
-    }
-  }
-  if (primaryFieldReadDenied) {
-    throw new Error(
-      "READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED" /* READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED */
-    );
-  }
-  return primaryField;
-};
-
-// src/common/TypeParsing/TypeParsing.ts
-var getTypeInfoMapFromTypeScript = (source) => {
-  const typeScriptNode = createSourceFile(
-    "x.ts",
-    source,
-    ScriptTarget.Latest,
-    true
-  );
-  const typeMap = convertASTToMap(typeScriptNode, {});
-  const typeInfoMap = {};
-  for (const key in typeMap) {
-    const typeAliasDec = typeMap[key];
-    const { modifiers } = typeAliasDec;
-    let outputTypeInfo = false;
-    if (modifiers) {
-      modifiers.forEach((modifier) => {
-        const { kind } = modifier;
-        if (kind === SyntaxKind.ExportKeyword) {
-          outputTypeInfo = true;
+    },
+    tags: {},
+    primaryField: "sign"
+  },
+  AbridgedS3ClientConfig: {
+    fields: {
+      requestHandler: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      apiVersion: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      sha256: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      urlParser: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      bodyLengthChecker: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      streamCollector: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      base64Decoder: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      base64Encoder: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      utf8Decoder: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      utf8Encoder: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      runtime: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      disableHostPrefix: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      serviceId: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      useDualstackEndpoint: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      useFipsEndpoint: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      region: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      credentialDefaultProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      signingEscapePath: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      useArnRegion: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      defaultUserAgentProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      streamHasher: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      md5: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      sha1: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      getAwsChunkedEncodingStream: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      maxAttempts: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      retryMode: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      logger: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      extensions: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      eventStreamSerdeProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      defaultsMode: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [
+          "standard",
+          "in-region",
+          "cross-region",
+          "mobile",
+          "auto",
+          "legacy"
+        ],
+        tags: {
+          allowCustomSelection: true
         }
-      });
-    }
-    if (outputTypeInfo) {
-      const typeInfo = getTypeInfoFromTypeAlias(typeAliasDec, typeMap);
-      if (typeInfo) {
-        typeInfoMap[key] = {
-          ...typeInfo,
-          primaryField: getPrimaryFieldForTypeInfo(typeInfo)
-        };
+      },
+      sdkStreamMixin: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      endpoint: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      endpointProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      tls: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      retryStrategy: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      credentials: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      signer: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      systemClockOffset: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      signingRegion: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      signerConstructor: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      forcePathStyle: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      useAccelerateEndpoint: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      disableMultiregionAccessPoints: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      followRegionRedirects: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      s3ExpressIdentityProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      customUserAgent: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      useGlobalEndpoint: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      disableS3ExpressSessionAuth: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
       }
-    }
+    },
+    tags: {},
+    primaryField: "requestHandler"
+  },
+  S3SpecificConfig: {
+    fields: {
+      s3Config: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        typeReference: "AbridgedS3ClientConfig",
+        tags: {}
+      },
+      bucketName: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      urlExpirationInSeconds: {
+        type: "number",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      }
+    },
+    tags: {},
+    primaryField: "s3Config"
   }
-  return typeInfoMap;
 };
 
-// src/common/TypeParsing/Validation.ts
-var Validation_exports = {};
-__export(Validation_exports, {
-  DENIED_TYPE_OPERATIONS: () => DENIED_TYPE_OPERATIONS,
-  ERROR_MESSAGE_CONSTANTS: () => ERROR_MESSAGE_CONSTANTS,
-  INVALID_CUSTOM_TYPE: () => INVALID_CUSTOM_TYPE,
-  PRIMITIVE_ERROR_MESSAGE_CONSTANTS: () => PRIMITIVE_ERROR_MESSAGE_CONSTANTS,
-  RelationshipValidationType: () => RelationshipValidationType,
-  TYPE_KEYWORD_VALIDATORS: () => TYPE_KEYWORD_VALIDATORS,
-  getValidityValue: () => getValidityValue,
-  hasValue: () => hasValue,
-  validateArrayOfTypeInfoFieldValues: () => validateArrayOfTypeInfoFieldValues,
-  validateCustomType: () => validateCustomType,
-  validateKeywordType: () => validateKeywordType,
-  validateTypeInfoFieldOperationAllowed: () => validateTypeInfoFieldOperationAllowed,
-  validateTypeInfoFieldValue: () => validateTypeInfoFieldValue,
-  validateTypeInfoValue: () => validateTypeInfoValue,
-  validateTypeOperationAllowed: () => validateTypeOperationAllowed,
-  validateValueMatchesPattern: () => validateValueMatchesPattern
-});
-
-// src/common/TypeParsing/TypeInfo.ts
-var TypeInfo_exports = {};
-__export(TypeInfo_exports, {
-  TypeOperation: () => TypeOperation
-});
-var TypeOperation = /* @__PURE__ */ ((TypeOperation2) => {
-  TypeOperation2["CREATE"] = "CREATE";
-  TypeOperation2["READ"] = "READ";
-  TypeOperation2["UPDATE"] = "UPDATE";
-  TypeOperation2["DELETE"] = "DELETE";
-  return TypeOperation2;
-})(TypeOperation || {});
-
-// src/common/TypeParsing/Validation.ts
-var RelationshipValidationType = /* @__PURE__ */ ((RelationshipValidationType2) => {
-  RelationshipValidationType2["INCLUDE"] = "INCLUDE";
-  RelationshipValidationType2["EXCLUDE"] = "EXCLUDE";
-  RelationshipValidationType2["STRICT_EXCLUDE"] = "STRICT_EXCLUDE";
-  return RelationshipValidationType2;
-})(RelationshipValidationType || {});
-var INVALID_CUSTOM_TYPE = "INVALID_CUSTOM_TYPE";
-var PRIMITIVE_ERROR_MESSAGE_CONSTANTS = {
-  string: "NOT_A_STRING",
-  number: "NOT_A_NUMBER",
-  boolean: "NOT_A_BOOLEAN"
-};
-var ERROR_MESSAGE_CONSTANTS = {
-  MISSING: "MISSING",
-  INVALID_OPTION: "INVALID_OPTION",
-  INVALID_FIELD: "INVALID_FIELD",
-  RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED: "RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED",
-  INVALID_TYPE: "INVALID_TYPE",
-  NO_UNION_TYPE_MATCHED: "NO_UNION_TYPE_MATCHED",
-  TYPE_DOES_NOT_EXIST: "TYPE_DOES_NOT_EXIST",
-  INVALID_PATTERN: "INVALID_PATTERN",
-  VALUE_DOES_NOT_MATCH_PATTERN: "VALUE_DOES_NOT_MATCH_PATTERN"
-};
-var DENIED_TYPE_OPERATIONS = {
-  CREATE: "DENIED_TYPE_OPERATION_CREATE",
-  READ: "DENIED_TYPE_OPERATION_READ",
-  UPDATE: "DENIED_TYPE_OPERATION_UPDATE",
-  DELETE: "DENIED_TYPE_OPERATION_DELETE"
-};
-var validateValueMatchesPattern = (typeName, value, pattern) => {
-  const results = {
-    typeName,
-    valid: true,
-    error: "",
-    errorMap: {}
-  };
-  const valueSupplied = typeof value !== "undefined";
-  const patternSupplied = typeof pattern === "string" && pattern.trim() !== "";
-  if (!valueSupplied || !patternSupplied) {
-    try {
-      const regex = new RegExp(pattern);
-      const testResult = typeof value === "string" && regex.test(value);
-      if (!testResult) {
-        results.valid = false;
-        results.error = ERROR_MESSAGE_CONSTANTS.VALUE_DOES_NOT_MATCH_PATTERN;
-      }
-    } catch (e) {
-      results.valid = false;
-      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_PATTERN;
-    }
-  }
-  return results;
-};
-var getValidityValue = (existing, pending) => !existing ? false : pending;
-var TYPE_KEYWORD_VALIDATORS = {
-  string: (value) => typeof value === "string",
-  number: (value) => typeof value === "number",
-  boolean: (value) => typeof value === "boolean"
-};
-var hasValue = (value) => value ?? false;
-var validateKeywordType = (value, type) => {
-  const validator = TYPE_KEYWORD_VALIDATORS[type];
-  let valid = true;
-  if (validator) {
-    valid = validator(value);
-  }
-  return valid;
-};
-var validateCustomType = (value, customType, customValidators) => {
-  let valid = true;
-  if (customValidators && customType) {
-    const validator = customValidators[customType];
-    if (validator) {
-      try {
-        valid = validator(value);
-      } catch (e) {
-        valid = false;
-      }
-    }
-  }
-  return valid;
-};
-var validateTypeInfoFieldValue = (value, typeInfoField, typeInfoMap, ignoreArray = false, strict = false, customValidators, typeOperation, relationshipValidationType = "STRICT_EXCLUDE" /* STRICT_EXCLUDE */, itemIsPartial) => {
-  const {
-    type,
-    typeReference,
-    array,
-    optional,
-    possibleValues,
-    tags: { customType, constraints: { pattern = void 0 } = {} } = {}
-  } = typeInfoField;
-  const results = {
-    typeName: typeReference ?? type,
-    valid: true,
-    error: "",
-    errorMap: {}
-  };
-  const requiredValueAllowed = !typeReference || relationshipValidationType === "INCLUDE" /* INCLUDE */;
-  if (requiredValueAllowed && !itemIsPartial && !optional && !hasValue(value)) {
-    results.valid = false;
-    results.error = ERROR_MESSAGE_CONSTANTS.MISSING;
-  } else if (array && !ignoreArray) {
-    const {
-      valid: validArray,
-      error: arrayError,
-      errorMap: arrayErrorMap
-    } = validateArrayOfTypeInfoFieldValues(
-      value,
-      typeInfoField,
-      typeInfoMap,
-      strict,
-      customValidators,
-      typeOperation,
-      relationshipValidationType,
-      itemIsPartial
-    );
-    results.valid = getValidityValue(results.valid, validArray);
-    results.error = arrayError;
-    results.errorMap = arrayErrorMap;
-  } else {
-    if (typeReference) {
-      if (relationshipValidationType === "INCLUDE" /* INCLUDE */) {
-        const {
-          valid: validTypeInfo,
-          error: typeInfoError,
-          errorMap: typeInfoErrorMap
-        } = validateTypeInfoValue(
-          value,
-          typeReference,
-          typeInfoMap,
-          strict,
-          customValidators,
-          typeOperation,
-          relationshipValidationType,
-          itemIsPartial
-        );
-        results.valid = getValidityValue(results.valid, validTypeInfo);
-        results.error = typeInfoError;
-        results.errorMap = typeInfoErrorMap;
-      } else if (relationshipValidationType === "STRICT_EXCLUDE" /* STRICT_EXCLUDE */) {
-        const valueSupplied = typeof value !== "undefined";
-        if (valueSupplied) {
-          results.valid = false;
-          results.error = ERROR_MESSAGE_CONSTANTS.RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED;
-        }
-      } else if (relationshipValidationType === "EXCLUDE" /* EXCLUDE */) {
-        results.valid = getValidityValue(results.valid, true);
-      }
-    } else if (possibleValues && !possibleValues.includes(value)) {
-      results.valid = false;
-      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_OPTION;
-    } else {
-      const pendingValid = validateKeywordType(value, type);
-      const customValid = validateCustomType(
-        value,
-        customType,
-        customValidators
-      );
-      results.valid = getValidityValue(results.valid, pendingValid);
-      results.valid = getValidityValue(results.valid, customValid);
-      if (type === "string" && typeof pattern === "string") {
-        const { valid: patternValid, error: patternError } = validateValueMatchesPattern(value, pattern);
-        results.valid = getValidityValue(results.valid, patternValid);
-        results.error = patternError;
-      }
-      if (!customValid) {
-        results.error = INVALID_CUSTOM_TYPE;
-      } else if (!results.valid) {
-        results.error = results.error ? results.error : PRIMITIVE_ERROR_MESSAGE_CONSTANTS[type];
-      }
-    }
-  }
-  return results;
-};
-var validateArrayOfTypeInfoFieldValues = (values = [], typeInfoField, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
-  const { type, typeReference } = typeInfoField;
-  const results = {
-    typeName: typeReference ?? type,
-    valid: true,
-    error: "",
-    errorMap: {}
-  };
-  for (let i = 0; i < values.length; i++) {
-    const v = values[i];
-    const {
-      valid: indexValid,
-      error: indexError = "",
-      errorMap: indexErrorMap
-    } = validateTypeInfoFieldValue(
-      v,
-      typeInfoField,
-      typeInfoMap,
-      true,
-      strict,
-      customValidators,
-      typeOperation,
-      relationshipValidationType,
-      itemIsPartial
-    );
-    results.valid = getValidityValue(results.valid, indexValid);
-    results.errorMap[getPathString([i])] = [indexError];
-    for (const er in indexErrorMap) {
-      results.errorMap[getPathString([i, er])] = indexErrorMap[er];
-    }
-  }
-  return results;
-};
-var validateTypeInfoFieldOperationAllowed = (fieldName, fieldOperation, typeInfoField) => {
-  const results = {
-    typeName: null,
-    valid: true,
-    error: "",
-    errorMap: {}
-  };
-  if (fieldOperation && typeInfoField) {
-    const {
-      type,
-      typeReference,
-      tags = {}
-    } = typeInfoField || {};
-    const { deniedOperations: { [fieldOperation]: denied = false } = {} } = tags;
-    results.typeName = typeReference ?? type;
-    results.valid = !denied;
-    if (!results.valid) {
-      results.error = DENIED_TYPE_OPERATIONS[fieldOperation];
-      results.errorMap[fieldName] = [results.error];
-    }
-  }
-  return results;
-};
-var validateTypeOperationAllowed = (typeName, valueFields, typeOperation, typeInfo) => {
-  const results = {
-    typeName,
-    valid: true,
-    error: "",
-    errorMap: {}
-  };
-  const { fields = {}, tags = {} } = typeInfo;
-  const { deniedOperations: { [typeOperation]: denied = false } = {} } = tags;
-  if (denied) {
-    results.valid = false;
-    results.error = DENIED_TYPE_OPERATIONS[typeOperation];
-  } else {
-    for (const vF of valueFields) {
-      const vFieldInfo = fields[vF];
-      const { valid: vFValid, error: vFError } = validateTypeInfoFieldOperationAllowed(vF, typeOperation, vFieldInfo);
-      results.valid = getValidityValue(results.valid, vFValid);
-      if (!vFValid) {
-        results.errorMap[vF] = [vFError];
-      }
-    }
-  }
-  return results;
-};
-var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
-  const typeInfo = typeInfoMap[typeInfoFullName];
-  const results = {
-    typeName: typeInfoFullName,
-    valid: !!typeInfo,
-    error: !!typeInfo ? "" : ERROR_MESSAGE_CONSTANTS.TYPE_DOES_NOT_EXIST,
-    errorMap: {}
-  };
-  if (typeInfo) {
-    const { primaryField, fields, unionFieldSets } = typeInfo;
-    if (typeOperation) {
-      const valueFields = typeof value === "object" ? Object.keys(value ?? {}) : [];
-      const {
-        valid: operationValid,
-        error: operationError,
-        errorMap: operationErrorMap
-      } = validateTypeOperationAllowed(
-        typeInfoFullName,
-        valueFields,
-        typeOperation,
-        typeInfo
-      );
-      results.valid = getValidityValue(results.valid, operationValid);
-      results.error = operationError;
-      for (const oE in operationErrorMap) {
-        const existingError = results.errorMap[oE] ?? [];
-        results.errorMap[oE] = existingError ? [...existingError, ...operationErrorMap[oE]] : operationErrorMap[oE];
-      }
-      if (!operationValid && operationError) {
-        results.error = operationError;
-      }
-    }
-    if (unionFieldSets) {
-      const valueFields = Object.keys(value || {});
-      let valid = false;
-      for (const uFS of unionFieldSets) {
-        valid = valueFields.every((vF) => uFS.includes(vF));
-        if (valid) {
-          break;
-        }
-      }
-      if (!valid) {
-        results.valid = false;
-        results.error = ERROR_MESSAGE_CONSTANTS.NO_UNION_TYPE_MATCHED;
-      }
-    } else if (strict) {
-      const knownFields = Object.keys(fields || {});
-      const valueFields = Object.keys(value || {});
-      for (const vF of valueFields) {
-        if (!knownFields.includes(vF)) {
-          results.valid = false;
-          results.errorMap[vF] = [ERROR_MESSAGE_CONSTANTS.INVALID_FIELD];
-        }
-      }
-    }
-    if (fields) {
-      for (const key in fields) {
-        if (typeOperation !== "CREATE" /* CREATE */ || typeof primaryField !== "string" || key !== primaryField) {
-          const typeInfoField = fields[key];
-          const fieldValue = value[key];
-          const {
-            valid: fieldValid,
-            error: fieldError,
-            errorMap: fieldErrorMap
-          } = validateTypeInfoFieldValue(
-            fieldValue,
-            typeInfoField,
-            typeInfoMap,
-            false,
-            strict,
-            customValidators,
-            typeOperation,
-            relationshipValidationType,
-            itemIsPartial
-          );
-          results.valid = getValidityValue(results.valid, fieldValid);
-          results.errorMap[key] = [fieldError];
-          for (const fE in fieldErrorMap) {
-            results.errorMap[getPathString([key, fE])] = fieldErrorMap[fE];
-          }
-        }
-      }
-    }
-    if (!results.valid && !results.error) {
-      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_TYPE;
-    }
-  }
-  return results;
-};
-
-// src/common/TypeParsing/Constants.ts
-var Constants_exports = {};
-__export(Constants_exports, {
-  BUILTIN_TYPE_NAMES: () => BUILTIN_TYPE_NAMES
-});
-var BUILTIN_TYPE_NAMES = [
-  "string",
-  "number",
-  "boolean",
-  "null",
-  "object",
-  "array",
-  "any",
-  "unknown",
-  "never"
-];
-
 // src/api/ORM/drivers/S3FileItemDBDriver.ts
-var moduleDirname = typeof __dirname === "string" ? __dirname : Path5.dirname(fileURLToPath(import.meta.url));
 var S3FileItemDBDriver = class {
   /**
    * @param config Driver configuration including S3 settings.
@@ -5219,20 +4816,424 @@ var S3SupportedFileItemDBDriverEntry = {
    * @returns Type info pack for the S3 config.
    */
   getDBSpecificConfigTypeInfo: () => {
-    const configTypesPath = Path5.join(
-      moduleDirname,
-      "S3FileItemDBDriver",
-      "ConfigTypes.ts"
-    );
-    const configTypesTS = FS.readFileSync(configTypesPath, "utf8");
-    const typeInfoMap = getTypeInfoMapFromTypeScript(configTypesTS);
     return {
       entryTypeName: "S3SpecificConfig",
-      typeInfoMap
+      typeInfoMap: ConfigTypeInfoMap_default
     };
   }
 };
-var moduleDirname2 = typeof __dirname === "string" ? __dirname : Path5.dirname(fileURLToPath(import.meta.url));
+
+// src/api/ORM/drivers/DynamoDBDataItemDBDriver/ConfigTypeInfoMap.json
+var ConfigTypeInfoMap_default2 = {
+  Logger: {
+    fields: {
+      trace: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      debug: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        typeReference: "Trace",
+        tags: {}
+      },
+      info: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        typeReference: "Trace",
+        tags: {}
+      },
+      warn: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        typeReference: "Trace",
+        tags: {}
+      },
+      error: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        typeReference: "Trace",
+        tags: {}
+      }
+    },
+    tags: {},
+    primaryField: "trace"
+  },
+  Endpoint: {
+    fields: {
+      protocol: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      hostname: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      port: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      path: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      },
+      query: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      }
+    },
+    tags: {},
+    primaryField: "protocol"
+  },
+  RetryStrategy: {
+    fields: {
+      mode: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      retry: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
+      }
+    },
+    tags: {},
+    primaryField: "mode"
+  },
+  DynamoDBSpecificConfig: {
+    fields: {
+      requestHandler: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      apiVersion: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      sha256: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      urlParser: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      bodyLengthChecker: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      streamCollector: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      base64Decoder: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      base64Encoder: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      utf8Decoder: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      utf8Encoder: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      runtime: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      disableHostPrefix: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      serviceId: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      useDualstackEndpoint: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      useFipsEndpoint: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      defaultUserAgentProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      region: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      credentialDefaultProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      maxAttempts: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      retryMode: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      logger: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      extensions: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      defaultsMode: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [
+          "standard",
+          "in-region",
+          "cross-region",
+          "mobile",
+          "auto",
+          "legacy"
+        ],
+        tags: {
+          allowCustomSelection: true
+        }
+      },
+      endpointDiscoveryEnabledProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      endpoint: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      endpointProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      tls: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      retryStrategy: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      customUserAgent: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      httpAuthSchemes: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      httpAuthSchemeProvider: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      credentials: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      signer: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      signingEscapePath: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      },
+      systemClockOffset: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      signingRegion: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      signerConstructor: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      endpointCacheSize: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      endpointDiscoveryEnabled: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        possibleValues: [],
+        tags: {}
+      }
+    },
+    tags: {},
+    primaryField: "requestHandler"
+  }
+};
+
+// src/api/ORM/drivers/DynamoDBDataItemDBDriver.ts
+typeof __dirname === "string" ? __dirname : Path4.dirname(fileURLToPath(import.meta.url));
 var DynamoDBOperatorMappings = {
   ["EQUALS" /* EQUALS */]: (fieldName) => `#${fieldName} = :${fieldName}`,
   ["NOT_EQUALS" /* NOT_EQUALS */]: (fieldName) => `#${fieldName} <> :${fieldName}`,
@@ -5505,20 +5506,23 @@ var DynamoDBSupportedDataItemDBDriverEntry = {
    * @returns Type info pack for the DynamoDB-specific config.
    */
   getDBSpecificConfigTypeInfo: () => {
-    const configTypesPath = Path5.join(
-      moduleDirname2,
-      "DynamoDBDataItemDBDriver",
-      "ConfigTypes.ts"
-    );
-    const configTypesTS = FS.readFileSync(configTypesPath, "utf8");
-    const typeInfoMap = getTypeInfoMapFromTypeScript(configTypesTS);
     return {
       entryTypeName: "DynamoDBSpecificConfig",
-      typeInfoMap
+      typeInfoMap: ConfigTypeInfoMap_default2
     };
   }
 };
-var moduleDirname3 = typeof __dirname === "string" ? __dirname : Path5.dirname(fileURLToPath(import.meta.url));
+
+// src/api/ORM/drivers/InMemoryDataItemDBDriver/ConfigTypeInfoMap.json
+var ConfigTypeInfoMap_default3 = {
+  InMemorySpecificConfig: {
+    fields: {},
+    tags: {}
+  }
+};
+
+// src/api/ORM/drivers/InMemoryDataItemDBDriver.ts
+typeof __dirname === "string" ? __dirname : Path4.dirname(fileURLToPath(import.meta.url));
 var decodeCursor2 = (cursor) => {
   if (!cursor) {
     return 0;
@@ -5564,7 +5568,9 @@ var InMemoryDataItemDBDriver = class {
       uniquelyIdentifyingFieldName,
       generateUniqueIdentifier = () => v4()
     } = this.config;
-    const newItemId = generateUniqueIdentifier(newItem);
+    const newItemId = generateUniqueIdentifier(
+      newItem
+    );
     const cleanNewItemWithId = {
       ...newItem,
       [uniquelyIdentifyingFieldName]: newItemId
@@ -5636,18 +5642,16 @@ var InMemoryDataItemDBDriver = class {
    * @returns List results with items and cursor.
    */
   listItems = async (config, selectedFields) => {
-    const {
-      itemsPerPage = 10,
-      cursor,
-      sortFields,
-      criteria
-    } = config;
+    const { itemsPerPage = 10, cursor, sortFields, criteria } = config;
     const allItems = Array.from(this.items.values());
     const filteredItems = criteria ? getFilterTypeInfoDataItemsBySearchCriteria(
       criteria,
       allItems
     ) : allItems;
-    const sortedItems = getSortedItems(sortFields, filteredItems);
+    const sortedItems = getSortedItems(
+      sortFields,
+      filteredItems
+    );
     const offset = decodeCursor2(cursor);
     const items = sortedItems.slice(offset, offset + itemsPerPage).map((item) => selectFieldsFromItem(item, selectedFields));
     const nextOffset = offset + itemsPerPage;
@@ -5669,16 +5673,9 @@ var InMemorySupportedDataItemDBDriverEntry = {
    * @returns Type info pack for the in-memory config.
    */
   getDBSpecificConfigTypeInfo: () => {
-    const configTypesPath = Path5.join(
-      moduleDirname3,
-      "InMemoryDataItemDBDriver",
-      "ConfigTypes.ts"
-    );
-    const configTypesTS = FS.readFileSync(configTypesPath, "utf8");
-    const typeInfoMap = getTypeInfoMapFromTypeScript(configTypesTS);
     return {
       entryTypeName: "InMemorySpecificConfig",
-      typeInfoMap
+      typeInfoMap: ConfigTypeInfoMap_default3
     };
   }
 };
@@ -5710,7 +5707,33 @@ var InMemoryItemRelationshipDBDriver = class extends InMemoryDataItemDBDriver {
     });
   }
 };
-var moduleDirname4 = typeof __dirname === "string" ? __dirname : Path5.dirname(fileURLToPath(import.meta.url));
+
+// src/api/ORM/drivers/InMemoryFileItemDBDriver/ConfigTypeInfoMap.json
+var ConfigTypeInfoMap_default4 = {
+  InMemoryFileSpecificConfig: {
+    fields: {
+      uploadUrlPrefix: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      downloadUrlPrefix: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      }
+    },
+    tags: {},
+    primaryField: "uploadUrlPrefix"
+  }
+};
+
+// src/api/ORM/drivers/InMemoryFileItemDBDriver.ts
+typeof __dirname === "string" ? __dirname : Path4.dirname(fileURLToPath(import.meta.url));
 var decodeCursor3 = (cursor) => {
   if (!cursor) {
     return 0;
@@ -5766,13 +5789,14 @@ var InMemoryFileItemDBDriver = class {
    * @returns Generated file id.
    */
   createItem = async (item) => {
-    const {
-      generateUniqueIdentifier
-    } = this.config;
+    const { generateUniqueIdentifier } = this.config;
     if (!item?.name) {
       throw new Error("MISSING_ID" /* MISSING_ID */);
     }
-    const fileLocation = { name: item.name, directory: item.directory };
+    const fileLocation = {
+      name: item.name,
+      directory: item.directory
+    };
     const id = typeof generateUniqueIdentifier === "function" ? String(generateUniqueIdentifier(item)) : getFullFileKey({ file: fileLocation });
     const mimeType = item.mimeType ?? "application/octet-stream";
     const newItem = {
@@ -5862,189 +5886,562 @@ var InMemoryFileItemDBDriver = class {
     this.aliases.delete(resolvedId);
     return true;
   };
-  /**
-   * List file items from memory.
-   * @returns List results with items and cursor.
-   */
-  listItems = async (config, selectFields) => {
-    const {
-      itemsPerPage = Infinity,
-      cursor,
-      sortFields = [],
-      criteria
-    } = config;
-    const allItems = Array.from(this.items.values());
-    const filteredItems = criteria ? getFilterTypeInfoDataItemsBySearchCriteria(
-      criteria,
-      allItems
-    ) : allItems;
-    const sortedItems = getSortedItems(sortFields, filteredItems);
-    const offset = decodeCursor3(cursor);
-    const slice = sortedItems.slice(offset, offset + itemsPerPage);
-    const expandedItems = slice.map((item) => {
-      const entry = { ...item };
-      if (selectFields?.includes("uploadUrl")) {
-        entry.uploadUrl = this.buildUrl(this.uploadUrlPrefix, item.id);
-      }
-      if (selectFields?.includes("downloadUrl")) {
-        entry.downloadUrl = this.buildUrl(this.downloadUrlPrefix, item.id);
+  /**
+   * List file items from memory.
+   * @returns List results with items and cursor.
+   */
+  listItems = async (config, selectFields) => {
+    const {
+      itemsPerPage = Infinity,
+      cursor,
+      sortFields = [],
+      criteria
+    } = config;
+    const allItems = Array.from(this.items.values());
+    const filteredItems = criteria ? getFilterTypeInfoDataItemsBySearchCriteria(
+      criteria,
+      allItems
+    ) : allItems;
+    const sortedItems = getSortedItems(
+      sortFields,
+      filteredItems
+    );
+    const offset = decodeCursor3(cursor);
+    const slice = sortedItems.slice(offset, offset + itemsPerPage);
+    const expandedItems = slice.map((item) => {
+      const entry = { ...item };
+      if (selectFields?.includes("uploadUrl")) {
+        entry.uploadUrl = this.buildUrl(this.uploadUrlPrefix, item.id);
+      }
+      if (selectFields?.includes("downloadUrl")) {
+        entry.downloadUrl = this.buildUrl(this.downloadUrlPrefix, item.id);
+      }
+      return selectFields ? selectFieldsFromItem2(entry, selectFields) : entry;
+    });
+    const nextOffset = offset + itemsPerPage;
+    return {
+      items: expandedItems,
+      cursor: nextOffset < sortedItems.length ? encodeCursor3(nextOffset) : void 0
+    };
+  };
+};
+var InMemoryFileSupportedDataItemDBDriverEntry = {
+  /**
+   * @param config Driver configuration.
+   * @returns In-memory file driver instance.
+   */
+  factory: (config) => {
+    return new InMemoryFileItemDBDriver(config);
+  },
+  /**
+   * @returns Type info pack for the in-memory file config.
+   */
+  getDBSpecificConfigTypeInfo: () => {
+    return {
+      entryTypeName: "InMemoryFileSpecificConfig",
+      typeInfoMap: ConfigTypeInfoMap_default4
+    };
+  }
+};
+
+// src/common/ItemRelationshipInfoTypes.ts
+var ItemRelationshipInfoTypes_exports = {};
+__export(ItemRelationshipInfoTypes_exports, {
+  ItemRelationshipInfoIdentifyingKeys: () => ItemRelationshipInfoIdentifyingKeys,
+  ItemRelationshipInfoKeys: () => ItemRelationshipInfoKeys
+});
+var ItemRelationshipInfoKeys = /* @__PURE__ */ ((ItemRelationshipInfoKeys2) => {
+  ItemRelationshipInfoKeys2["fromTypeName"] = "fromTypeName";
+  ItemRelationshipInfoKeys2["fromTypeFieldName"] = "fromTypeFieldName";
+  ItemRelationshipInfoKeys2["fromTypePrimaryFieldValue"] = "fromTypePrimaryFieldValue";
+  ItemRelationshipInfoKeys2["toTypePrimaryFieldValue"] = "toTypePrimaryFieldValue";
+  return ItemRelationshipInfoKeys2;
+})(ItemRelationshipInfoKeys || {});
+var ItemRelationshipInfoIdentifyingKeys = /* @__PURE__ */ ((ItemRelationshipInfoIdentifyingKeys2) => {
+  ItemRelationshipInfoIdentifyingKeys2["id"] = "id";
+  return ItemRelationshipInfoIdentifyingKeys2;
+})(ItemRelationshipInfoIdentifyingKeys || {});
+
+// src/api/ORM/drivers/IndexingRelationshipDriver.ts
+var defaultEncodeEntityId = (typeName, primaryFieldValue) => `${typeName}#${primaryFieldValue}`;
+var defaultDecodeEntityId = (typeName, entityId) => {
+  const prefix = `${typeName}#`;
+  return entityId.startsWith(prefix) ? entityId.slice(prefix.length) : entityId;
+};
+var buildRelationshipId = (edgeKey2) => `${edgeKey2.from}|${edgeKey2.relation}|${edgeKey2.to}`;
+var IndexingRelationshipDriver = class {
+  /**
+   * @param config Driver configuration for relation indexing.
+   */
+  constructor(config) {
+    this.config = config;
+    this.encodeEntityId = config.encodeEntityId ?? defaultEncodeEntityId;
+    this.decodeEntityId = config.decodeEntityId ?? defaultDecodeEntityId;
+  }
+  encodeEntityId;
+  decodeEntityId;
+  buildEdgeKey(relationship, toTypeName) {
+    const { fromTypeName, fromTypeFieldName, fromTypePrimaryFieldValue, toTypePrimaryFieldValue } = relationship;
+    const relation = this.config.relationNameFor(fromTypeName, fromTypeFieldName);
+    return {
+      from: this.encodeEntityId(fromTypeName, String(fromTypePrimaryFieldValue)),
+      to: this.encodeEntityId(toTypeName, String(toTypePrimaryFieldValue)),
+      relation
+    };
+  }
+  buildRelationshipInfo(edge, origin, toTypeName) {
+    const { fromTypeName, fromTypeFieldName } = origin;
+    const fromTypePrimaryFieldValue = this.decodeEntityId(fromTypeName, edge.key.from);
+    const toTypePrimaryFieldValue = this.decodeEntityId(toTypeName, edge.key.to);
+    return {
+      ["id" /* id */]: buildRelationshipId(edge.key),
+      ["fromTypeName" /* fromTypeName */]: fromTypeName,
+      ["fromTypeFieldName" /* fromTypeFieldName */]: fromTypeFieldName,
+      ["fromTypePrimaryFieldValue" /* fromTypePrimaryFieldValue */]: fromTypePrimaryFieldValue,
+      ["toTypePrimaryFieldValue" /* toTypePrimaryFieldValue */]: toTypePrimaryFieldValue
+    };
+  }
+  async removeAllOutgoing(fromId, relation) {
+    let cursor = void 0;
+    do {
+      const page = await this.config.backend.getOutgoing(fromId, relation, { limit: 100, cursor });
+      await Promise.all(page.edges.map((edge) => this.config.backend.removeEdge(edge.key)));
+      cursor = page.nextCursor;
+    } while (cursor);
+  }
+  /**
+   * Create a relationship via the relational backend.
+   * @returns Promise resolved once the relationship is stored.
+   */
+  async createRelationship(relationship, toTypeName, ensureSingle) {
+    const edgeKey2 = this.buildEdgeKey(relationship, toTypeName);
+    if (ensureSingle) {
+      await this.removeAllOutgoing(edgeKey2.from, edgeKey2.relation);
+    }
+    await this.config.backend.putEdge({ key: edgeKey2 });
+  }
+  /**
+   * Delete a relationship via the relational backend.
+   * @returns Promise resolved once the relationship is removed.
+   */
+  async deleteRelationship(relationship, toTypeName) {
+    const edgeKey2 = this.buildEdgeKey(relationship, toTypeName);
+    await this.config.backend.removeEdge(edgeKey2);
+  }
+  /**
+   * List relationships via the relational backend.
+   * @returns List results with items and cursor.
+   */
+  async listRelationships(config, toTypeName) {
+    const { relationshipItemOrigin, itemsPerPage, cursor } = config;
+    const { fromTypeName, fromTypeFieldName, fromTypePrimaryFieldValue } = relationshipItemOrigin;
+    const relation = this.config.relationNameFor(fromTypeName, fromTypeFieldName);
+    const fromId = this.encodeEntityId(fromTypeName, String(fromTypePrimaryFieldValue));
+    const options = {
+      limit: itemsPerPage,
+      cursor
+    };
+    const page = await this.config.backend.getOutgoing(fromId, relation, options);
+    const items = page.edges.map(
+      (edge) => this.buildRelationshipInfo(edge, relationshipItemOrigin, toTypeName)
+    );
+    return {
+      items,
+      cursor: page.nextCursor
+    };
+  }
+};
+
+// src/api/ORM/drivers/common/SupportedTypeInfoORMDBDrivers.ts
+var SupportedTypeInfoORMDBDriverNames = /* @__PURE__ */ ((SupportedTypeInfoORMDBDriverNames2) => {
+  SupportedTypeInfoORMDBDriverNames2["DYNAMO_DB_DATA_ITEM"] = "DYNAMO_DB_DATA_ITEM";
+  SupportedTypeInfoORMDBDriverNames2["IN_MEMORY_DATA_ITEM"] = "IN_MEMORY_DATA_ITEM";
+  SupportedTypeInfoORMDBDriverNames2["IN_MEMORY_FILE_ITEM"] = "IN_MEMORY_FILE_ITEM";
+  SupportedTypeInfoORMDBDriverNames2["S3_FILE_ITEM"] = "S3_FILE_ITEM";
+  return SupportedTypeInfoORMDBDriverNames2;
+})(SupportedTypeInfoORMDBDriverNames || {});
+var SUPPORTED_TYPE_INFO_ORM_DB_DRIVERS = {
+  ["DYNAMO_DB_DATA_ITEM" /* DYNAMO_DB_DATA_ITEM */]: DynamoDBSupportedDataItemDBDriverEntry,
+  ["IN_MEMORY_DATA_ITEM" /* IN_MEMORY_DATA_ITEM */]: InMemorySupportedDataItemDBDriverEntry,
+  ["IN_MEMORY_FILE_ITEM" /* IN_MEMORY_FILE_ITEM */]: InMemoryFileSupportedDataItemDBDriverEntry,
+  ["S3_FILE_ITEM" /* S3_FILE_ITEM */]: S3SupportedFileItemDBDriverEntry
+};
+
+// src/common/TypeParsing/TypeInfo.ts
+var TypeInfo_exports = {};
+__export(TypeInfo_exports, {
+  TypeOperation: () => TypeOperation
+});
+var TypeOperation = /* @__PURE__ */ ((TypeOperation2) => {
+  TypeOperation2["CREATE"] = "CREATE";
+  TypeOperation2["READ"] = "READ";
+  TypeOperation2["UPDATE"] = "UPDATE";
+  TypeOperation2["DELETE"] = "DELETE";
+  return TypeOperation2;
+})(TypeOperation || {});
+
+// src/common/TypeParsing/Validation.ts
+var Validation_exports = {};
+__export(Validation_exports, {
+  DENIED_TYPE_OPERATIONS: () => DENIED_TYPE_OPERATIONS,
+  ERROR_MESSAGE_CONSTANTS: () => ERROR_MESSAGE_CONSTANTS,
+  INVALID_CUSTOM_TYPE: () => INVALID_CUSTOM_TYPE,
+  PRIMITIVE_ERROR_MESSAGE_CONSTANTS: () => PRIMITIVE_ERROR_MESSAGE_CONSTANTS,
+  RelationshipValidationType: () => RelationshipValidationType,
+  TYPE_KEYWORD_VALIDATORS: () => TYPE_KEYWORD_VALIDATORS,
+  getValidityValue: () => getValidityValue,
+  hasValue: () => hasValue,
+  validateArrayOfTypeInfoFieldValues: () => validateArrayOfTypeInfoFieldValues,
+  validateCustomType: () => validateCustomType,
+  validateKeywordType: () => validateKeywordType,
+  validateTypeInfoFieldOperationAllowed: () => validateTypeInfoFieldOperationAllowed,
+  validateTypeInfoFieldValue: () => validateTypeInfoFieldValue,
+  validateTypeInfoValue: () => validateTypeInfoValue,
+  validateTypeOperationAllowed: () => validateTypeOperationAllowed,
+  validateValueMatchesPattern: () => validateValueMatchesPattern
+});
+var RelationshipValidationType = /* @__PURE__ */ ((RelationshipValidationType2) => {
+  RelationshipValidationType2["INCLUDE"] = "INCLUDE";
+  RelationshipValidationType2["EXCLUDE"] = "EXCLUDE";
+  RelationshipValidationType2["STRICT_EXCLUDE"] = "STRICT_EXCLUDE";
+  return RelationshipValidationType2;
+})(RelationshipValidationType || {});
+var INVALID_CUSTOM_TYPE = "INVALID_CUSTOM_TYPE";
+var PRIMITIVE_ERROR_MESSAGE_CONSTANTS = {
+  string: "NOT_A_STRING",
+  number: "NOT_A_NUMBER",
+  boolean: "NOT_A_BOOLEAN"
+};
+var ERROR_MESSAGE_CONSTANTS = {
+  MISSING: "MISSING",
+  INVALID_OPTION: "INVALID_OPTION",
+  INVALID_FIELD: "INVALID_FIELD",
+  RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED: "RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED",
+  INVALID_TYPE: "INVALID_TYPE",
+  NO_UNION_TYPE_MATCHED: "NO_UNION_TYPE_MATCHED",
+  TYPE_DOES_NOT_EXIST: "TYPE_DOES_NOT_EXIST",
+  INVALID_PATTERN: "INVALID_PATTERN",
+  VALUE_DOES_NOT_MATCH_PATTERN: "VALUE_DOES_NOT_MATCH_PATTERN"
+};
+var DENIED_TYPE_OPERATIONS = {
+  CREATE: "DENIED_TYPE_OPERATION_CREATE",
+  READ: "DENIED_TYPE_OPERATION_READ",
+  UPDATE: "DENIED_TYPE_OPERATION_UPDATE",
+  DELETE: "DENIED_TYPE_OPERATION_DELETE"
+};
+var validateValueMatchesPattern = (typeName, value, pattern) => {
+  const results = {
+    typeName,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  const valueSupplied = typeof value !== "undefined";
+  const patternSupplied = typeof pattern === "string" && pattern.trim() !== "";
+  if (!valueSupplied || !patternSupplied) {
+    try {
+      const regex = new RegExp(pattern);
+      const testResult = typeof value === "string" && regex.test(value);
+      if (!testResult) {
+        results.valid = false;
+        results.error = ERROR_MESSAGE_CONSTANTS.VALUE_DOES_NOT_MATCH_PATTERN;
       }
-      return selectFields ? selectFieldsFromItem2(entry, selectFields) : entry;
-    });
-    const nextOffset = offset + itemsPerPage;
-    return {
-      items: expandedItems,
-      cursor: nextOffset < sortedItems.length ? encodeCursor3(nextOffset) : void 0
-    };
-  };
-};
-var InMemoryFileSupportedDataItemDBDriverEntry = {
-  /**
-   * @param config Driver configuration.
-   * @returns In-memory file driver instance.
-   */
-  factory: (config) => {
-    return new InMemoryFileItemDBDriver(config);
-  },
-  /**
-   * @returns Type info pack for the in-memory file config.
-   */
-  getDBSpecificConfigTypeInfo: () => {
-    const configTypesPath = Path5.join(
-      moduleDirname4,
-      "InMemoryFileItemDBDriver",
-      "ConfigTypes.ts"
-    );
-    const configTypesTS = FS.readFileSync(configTypesPath, "utf8");
-    const typeInfoMap = getTypeInfoMapFromTypeScript(configTypesTS);
-    return {
-      entryTypeName: "InMemoryFileSpecificConfig",
-      typeInfoMap
-    };
+    } catch (e) {
+      results.valid = false;
+      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_PATTERN;
+    }
   }
+  return results;
 };
-
-// src/common/ItemRelationshipInfoTypes.ts
-var ItemRelationshipInfoTypes_exports = {};
-__export(ItemRelationshipInfoTypes_exports, {
-  ItemRelationshipInfoIdentifyingKeys: () => ItemRelationshipInfoIdentifyingKeys,
-  ItemRelationshipInfoKeys: () => ItemRelationshipInfoKeys
-});
-var ItemRelationshipInfoKeys = /* @__PURE__ */ ((ItemRelationshipInfoKeys2) => {
-  ItemRelationshipInfoKeys2["fromTypeName"] = "fromTypeName";
-  ItemRelationshipInfoKeys2["fromTypeFieldName"] = "fromTypeFieldName";
-  ItemRelationshipInfoKeys2["fromTypePrimaryFieldValue"] = "fromTypePrimaryFieldValue";
-  ItemRelationshipInfoKeys2["toTypePrimaryFieldValue"] = "toTypePrimaryFieldValue";
-  return ItemRelationshipInfoKeys2;
-})(ItemRelationshipInfoKeys || {});
-var ItemRelationshipInfoIdentifyingKeys = /* @__PURE__ */ ((ItemRelationshipInfoIdentifyingKeys2) => {
-  ItemRelationshipInfoIdentifyingKeys2["id"] = "id";
-  return ItemRelationshipInfoIdentifyingKeys2;
-})(ItemRelationshipInfoIdentifyingKeys || {});
-
-// src/api/ORM/drivers/IndexingRelationshipDriver.ts
-var defaultEncodeEntityId = (typeName, primaryFieldValue) => `${typeName}#${primaryFieldValue}`;
-var defaultDecodeEntityId = (typeName, entityId) => {
-  const prefix = `${typeName}#`;
-  return entityId.startsWith(prefix) ? entityId.slice(prefix.length) : entityId;
+var getValidityValue = (existing, pending) => !existing ? false : pending;
+var TYPE_KEYWORD_VALIDATORS = {
+  string: (value) => typeof value === "string",
+  number: (value) => typeof value === "number",
+  boolean: (value) => typeof value === "boolean"
 };
-var buildRelationshipId = (edgeKey2) => `${edgeKey2.from}|${edgeKey2.relation}|${edgeKey2.to}`;
-var IndexingRelationshipDriver = class {
-  /**
-   * @param config Driver configuration for relation indexing.
-   */
-  constructor(config) {
-    this.config = config;
-    this.encodeEntityId = config.encodeEntityId ?? defaultEncodeEntityId;
-    this.decodeEntityId = config.decodeEntityId ?? defaultDecodeEntityId;
-  }
-  encodeEntityId;
-  decodeEntityId;
-  buildEdgeKey(relationship, toTypeName) {
-    const { fromTypeName, fromTypeFieldName, fromTypePrimaryFieldValue, toTypePrimaryFieldValue } = relationship;
-    const relation = this.config.relationNameFor(fromTypeName, fromTypeFieldName);
-    return {
-      from: this.encodeEntityId(fromTypeName, String(fromTypePrimaryFieldValue)),
-      to: this.encodeEntityId(toTypeName, String(toTypePrimaryFieldValue)),
-      relation
-    };
+var hasValue = (value) => value ?? false;
+var validateKeywordType = (value, type) => {
+  const validator = TYPE_KEYWORD_VALIDATORS[type];
+  let valid = true;
+  if (validator) {
+    valid = validator(value);
   }
-  buildRelationshipInfo(edge, origin, toTypeName) {
-    const { fromTypeName, fromTypeFieldName } = origin;
-    const fromTypePrimaryFieldValue = this.decodeEntityId(fromTypeName, edge.key.from);
-    const toTypePrimaryFieldValue = this.decodeEntityId(toTypeName, edge.key.to);
-    return {
-      ["id" /* id */]: buildRelationshipId(edge.key),
-      ["fromTypeName" /* fromTypeName */]: fromTypeName,
-      ["fromTypeFieldName" /* fromTypeFieldName */]: fromTypeFieldName,
-      ["fromTypePrimaryFieldValue" /* fromTypePrimaryFieldValue */]: fromTypePrimaryFieldValue,
-      ["toTypePrimaryFieldValue" /* toTypePrimaryFieldValue */]: toTypePrimaryFieldValue
-    };
+  return valid;
+};
+var validateCustomType = (value, customType, customValidators) => {
+  let valid = true;
+  if (customValidators && customType) {
+    const validator = customValidators[customType];
+    if (validator) {
+      try {
+        valid = validator(value);
+      } catch (e) {
+        valid = false;
+      }
+    }
   }
-  async removeAllOutgoing(fromId, relation) {
-    let cursor = void 0;
-    do {
-      const page = await this.config.backend.getOutgoing(fromId, relation, { limit: 100, cursor });
-      await Promise.all(page.edges.map((edge) => this.config.backend.removeEdge(edge.key)));
-      cursor = page.nextCursor;
-    } while (cursor);
+  return valid;
+};
+var validateTypeInfoFieldValue = (value, typeInfoField, typeInfoMap, ignoreArray = false, strict = false, customValidators, typeOperation, relationshipValidationType = "STRICT_EXCLUDE" /* STRICT_EXCLUDE */, itemIsPartial) => {
+  const {
+    type,
+    typeReference,
+    array,
+    optional,
+    possibleValues,
+    tags: { customType, constraints: { pattern = void 0 } = {} } = {}
+  } = typeInfoField;
+  const results = {
+    typeName: typeReference ?? type,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  const requiredValueAllowed = !typeReference || relationshipValidationType === "INCLUDE" /* INCLUDE */;
+  if (requiredValueAllowed && !itemIsPartial && !optional && !hasValue(value)) {
+    results.valid = false;
+    results.error = ERROR_MESSAGE_CONSTANTS.MISSING;
+  } else if (array && !ignoreArray) {
+    const {
+      valid: validArray,
+      error: arrayError,
+      errorMap: arrayErrorMap
+    } = validateArrayOfTypeInfoFieldValues(
+      value,
+      typeInfoField,
+      typeInfoMap,
+      strict,
+      customValidators,
+      typeOperation,
+      relationshipValidationType,
+      itemIsPartial
+    );
+    results.valid = getValidityValue(results.valid, validArray);
+    results.error = arrayError;
+    results.errorMap = arrayErrorMap;
+  } else {
+    if (typeReference) {
+      if (relationshipValidationType === "INCLUDE" /* INCLUDE */) {
+        const {
+          valid: validTypeInfo,
+          error: typeInfoError,
+          errorMap: typeInfoErrorMap
+        } = validateTypeInfoValue(
+          value,
+          typeReference,
+          typeInfoMap,
+          strict,
+          customValidators,
+          typeOperation,
+          relationshipValidationType,
+          itemIsPartial
+        );
+        results.valid = getValidityValue(results.valid, validTypeInfo);
+        results.error = typeInfoError;
+        results.errorMap = typeInfoErrorMap;
+      } else if (relationshipValidationType === "STRICT_EXCLUDE" /* STRICT_EXCLUDE */) {
+        const valueSupplied = typeof value !== "undefined";
+        if (valueSupplied) {
+          results.valid = false;
+          results.error = ERROR_MESSAGE_CONSTANTS.RELATIONSHIP_VALUES_ARE_STRICTLY_EXCLUDED;
+        }
+      } else if (relationshipValidationType === "EXCLUDE" /* EXCLUDE */) {
+        results.valid = getValidityValue(results.valid, true);
+      }
+    } else if (possibleValues && !possibleValues.includes(value)) {
+      results.valid = false;
+      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_OPTION;
+    } else {
+      const pendingValid = validateKeywordType(value, type);
+      const customValid = validateCustomType(
+        value,
+        customType,
+        customValidators
+      );
+      results.valid = getValidityValue(results.valid, pendingValid);
+      results.valid = getValidityValue(results.valid, customValid);
+      if (type === "string" && typeof pattern === "string") {
+        const { valid: patternValid, error: patternError } = validateValueMatchesPattern(value, pattern);
+        results.valid = getValidityValue(results.valid, patternValid);
+        results.error = patternError;
+      }
+      if (!customValid) {
+        results.error = INVALID_CUSTOM_TYPE;
+      } else if (!results.valid) {
+        results.error = results.error ? results.error : PRIMITIVE_ERROR_MESSAGE_CONSTANTS[type];
+      }
+    }
   }
-  /**
-   * Create a relationship via the relational backend.
-   * @returns Promise resolved once the relationship is stored.
-   */
-  async createRelationship(relationship, toTypeName, ensureSingle) {
-    const edgeKey2 = this.buildEdgeKey(relationship, toTypeName);
-    if (ensureSingle) {
-      await this.removeAllOutgoing(edgeKey2.from, edgeKey2.relation);
+  return results;
+};
+var validateArrayOfTypeInfoFieldValues = (values = [], typeInfoField, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
+  const { type, typeReference } = typeInfoField;
+  const results = {
+    typeName: typeReference ?? type,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    const {
+      valid: indexValid,
+      error: indexError = "",
+      errorMap: indexErrorMap
+    } = validateTypeInfoFieldValue(
+      v,
+      typeInfoField,
+      typeInfoMap,
+      true,
+      strict,
+      customValidators,
+      typeOperation,
+      relationshipValidationType,
+      itemIsPartial
+    );
+    results.valid = getValidityValue(results.valid, indexValid);
+    results.errorMap[getPathString([i])] = [indexError];
+    for (const er in indexErrorMap) {
+      results.errorMap[getPathString([i, er])] = indexErrorMap[er];
     }
-    await this.config.backend.putEdge({ key: edgeKey2 });
   }
-  /**
-   * Delete a relationship via the relational backend.
-   * @returns Promise resolved once the relationship is removed.
-   */
-  async deleteRelationship(relationship, toTypeName) {
-    const edgeKey2 = this.buildEdgeKey(relationship, toTypeName);
-    await this.config.backend.removeEdge(edgeKey2);
+  return results;
+};
+var validateTypeInfoFieldOperationAllowed = (fieldName, fieldOperation, typeInfoField) => {
+  const results = {
+    typeName: null,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  if (fieldOperation && typeInfoField) {
+    const {
+      type,
+      typeReference,
+      tags = {}
+    } = typeInfoField || {};
+    const { deniedOperations: { [fieldOperation]: denied = false } = {} } = tags;
+    results.typeName = typeReference ?? type;
+    results.valid = !denied;
+    if (!results.valid) {
+      results.error = DENIED_TYPE_OPERATIONS[fieldOperation];
+      results.errorMap[fieldName] = [results.error];
+    }
   }
-  /**
-   * List relationships via the relational backend.
-   * @returns List results with items and cursor.
-   */
-  async listRelationships(config, toTypeName) {
-    const { relationshipItemOrigin, itemsPerPage, cursor } = config;
-    const { fromTypeName, fromTypeFieldName, fromTypePrimaryFieldValue } = relationshipItemOrigin;
-    const relation = this.config.relationNameFor(fromTypeName, fromTypeFieldName);
-    const fromId = this.encodeEntityId(fromTypeName, String(fromTypePrimaryFieldValue));
-    const options = {
-      limit: itemsPerPage,
-      cursor
-    };
-    const page = await this.config.backend.getOutgoing(fromId, relation, options);
-    const items = page.edges.map(
-      (edge) => this.buildRelationshipInfo(edge, relationshipItemOrigin, toTypeName)
-    );
-    return {
-      items,
-      cursor: page.nextCursor
-    };
+  return results;
+};
+var validateTypeOperationAllowed = (typeName, valueFields, typeOperation, typeInfo) => {
+  const results = {
+    typeName,
+    valid: true,
+    error: "",
+    errorMap: {}
+  };
+  const { fields = {}, tags = {} } = typeInfo;
+  const { deniedOperations: { [typeOperation]: denied = false } = {} } = tags;
+  if (denied) {
+    results.valid = false;
+    results.error = DENIED_TYPE_OPERATIONS[typeOperation];
+  } else {
+    for (const vF of valueFields) {
+      const vFieldInfo = fields[vF];
+      const { valid: vFValid, error: vFError } = validateTypeInfoFieldOperationAllowed(vF, typeOperation, vFieldInfo);
+      results.valid = getValidityValue(results.valid, vFValid);
+      if (!vFValid) {
+        results.errorMap[vF] = [vFError];
+      }
+    }
   }
+  return results;
 };
-
-// src/api/ORM/drivers/common/SupportedTypeInfoORMDBDrivers.ts
-var SupportedTypeInfoORMDBDriverNames = /* @__PURE__ */ ((SupportedTypeInfoORMDBDriverNames2) => {
-  SupportedTypeInfoORMDBDriverNames2["DYNAMO_DB_DATA_ITEM"] = "DYNAMO_DB_DATA_ITEM";
-  SupportedTypeInfoORMDBDriverNames2["IN_MEMORY_DATA_ITEM"] = "IN_MEMORY_DATA_ITEM";
-  SupportedTypeInfoORMDBDriverNames2["IN_MEMORY_FILE_ITEM"] = "IN_MEMORY_FILE_ITEM";
-  SupportedTypeInfoORMDBDriverNames2["S3_FILE_ITEM"] = "S3_FILE_ITEM";
-  return SupportedTypeInfoORMDBDriverNames2;
-})(SupportedTypeInfoORMDBDriverNames || {});
-var SUPPORTED_TYPE_INFO_ORM_DB_DRIVERS = {
-  ["DYNAMO_DB_DATA_ITEM" /* DYNAMO_DB_DATA_ITEM */]: DynamoDBSupportedDataItemDBDriverEntry,
-  ["IN_MEMORY_DATA_ITEM" /* IN_MEMORY_DATA_ITEM */]: InMemorySupportedDataItemDBDriverEntry,
-  ["IN_MEMORY_FILE_ITEM" /* IN_MEMORY_FILE_ITEM */]: InMemoryFileSupportedDataItemDBDriverEntry,
-  ["S3_FILE_ITEM" /* S3_FILE_ITEM */]: S3SupportedFileItemDBDriverEntry
+var validateTypeInfoValue = (value, typeInfoFullName, typeInfoMap, strict = false, customValidators, typeOperation, relationshipValidationType, itemIsPartial) => {
+  const typeInfo = typeInfoMap[typeInfoFullName];
+  const results = {
+    typeName: typeInfoFullName,
+    valid: !!typeInfo,
+    error: !!typeInfo ? "" : ERROR_MESSAGE_CONSTANTS.TYPE_DOES_NOT_EXIST,
+    errorMap: {}
+  };
+  if (typeInfo) {
+    const { primaryField, fields, unionFieldSets } = typeInfo;
+    if (typeOperation) {
+      const valueFields = typeof value === "object" ? Object.keys(value ?? {}) : [];
+      const {
+        valid: operationValid,
+        error: operationError,
+        errorMap: operationErrorMap
+      } = validateTypeOperationAllowed(
+        typeInfoFullName,
+        valueFields,
+        typeOperation,
+        typeInfo
+      );
+      results.valid = getValidityValue(results.valid, operationValid);
+      results.error = operationError;
+      for (const oE in operationErrorMap) {
+        const existingError = results.errorMap[oE] ?? [];
+        results.errorMap[oE] = existingError ? [...existingError, ...operationErrorMap[oE]] : operationErrorMap[oE];
+      }
+      if (!operationValid && operationError) {
+        results.error = operationError;
+      }
+    }
+    if (unionFieldSets) {
+      const valueFields = Object.keys(value || {});
+      let valid = false;
+      for (const uFS of unionFieldSets) {
+        valid = valueFields.every((vF) => uFS.includes(vF));
+        if (valid) {
+          break;
+        }
+      }
+      if (!valid) {
+        results.valid = false;
+        results.error = ERROR_MESSAGE_CONSTANTS.NO_UNION_TYPE_MATCHED;
+      }
+    } else if (strict) {
+      const knownFields = Object.keys(fields || {});
+      const valueFields = Object.keys(value || {});
+      for (const vF of valueFields) {
+        if (!knownFields.includes(vF)) {
+          results.valid = false;
+          results.errorMap[vF] = [ERROR_MESSAGE_CONSTANTS.INVALID_FIELD];
+        }
+      }
+    }
+    if (fields) {
+      for (const key in fields) {
+        if (typeOperation !== "CREATE" /* CREATE */ || typeof primaryField !== "string" || key !== primaryField) {
+          const typeInfoField = fields[key];
+          const fieldValue = value[key];
+          const {
+            valid: fieldValid,
+            error: fieldError,
+            errorMap: fieldErrorMap
+          } = validateTypeInfoFieldValue(
+            fieldValue,
+            typeInfoField,
+            typeInfoMap,
+            false,
+            strict,
+            customValidators,
+            typeOperation,
+            relationshipValidationType,
+            itemIsPartial
+          );
+          results.valid = getValidityValue(results.valid, fieldValid);
+          results.errorMap[key] = [fieldError];
+          for (const fE in fieldErrorMap) {
+            results.errorMap[getPathString([key, fE])] = fieldErrorMap[fE];
+          }
+        }
+      }
+    }
+    if (!results.valid && !results.error) {
+      results.error = ERROR_MESSAGE_CONSTANTS.INVALID_TYPE;
+    }
+  }
+  return results;
 };
 
 // src/common/SearchValidation.ts
@@ -9991,7 +10388,8 @@ var addCloudFunction = createResourcePack(
           ]
         }
       }
-    ]
+    ],
+    memorySize = 128
   }) => {
     return {
       Resources: {
@@ -10026,7 +10424,8 @@ var addCloudFunction = createResourcePack(
             Role: {
               "Fn::GetAtt": [`${id}Role`, "Arn"]
             },
-            Runtime: runtime
+            Runtime: runtime,
+            MemorySize: memorySize
           }
         }
       }
@@ -10588,6 +10987,62 @@ __export(common_exports, {
   TypeParsing: () => TypeParsing_exports
 });
 
+// src/common/TypeParsing/index.ts
+var TypeParsing_exports = {};
+__export(TypeParsing_exports, {
+  Constants: () => Constants_exports,
+  TypeInfo: () => TypeInfo_exports,
+  TypeMapping: () => TypeMapping_exports,
+  Validation: () => Validation_exports
+});
+
+// src/common/TypeParsing/TypeMapping.ts
+var TypeMapping_exports = {};
+__export(TypeMapping_exports, {
+  convertASTToMap: () => convertASTToMap
+});
+var convertASTToMap = (node, map = {}, parentName) => {
+  node.forEachChild((child) => {
+    const { kind: childKind } = child;
+    if (childKind === SyntaxKind.ModuleDeclaration) {
+      const moduleNode = child;
+      const { name: moduleName } = moduleNode;
+      const textModuleName = moduleName.getText();
+      const fullModuleName = parentName ? `${parentName}.${textModuleName}` : textModuleName;
+      convertASTToMap(moduleNode, map, fullModuleName);
+    }
+    if (childKind === SyntaxKind.ModuleBlock) {
+      convertASTToMap(child, map, parentName);
+    }
+    if (childKind === SyntaxKind.TypeAliasDeclaration) {
+      const typeAliasDec = child;
+      const {
+        name: { text: typeName }
+      } = typeAliasDec;
+      const fullTypeName = parentName ? `${parentName}.${typeName}` : typeName;
+      map[fullTypeName] = typeAliasDec;
+    }
+  });
+  return map;
+};
+
+// src/common/TypeParsing/Constants.ts
+var Constants_exports = {};
+__export(Constants_exports, {
+  BUILTIN_TYPE_NAMES: () => BUILTIN_TYPE_NAMES
+});
+var BUILTIN_TYPE_NAMES = [
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "object",
+  "array",
+  "any",
+  "unknown",
+  "never"
+];
+
 // src/common/StringTransformers.ts
 var StringTransformers_exports = {};
 __export(StringTransformers_exports, {
@@ -10741,7 +11196,7 @@ var getResolvedConditions = async (testFilePath, targetTestIndex, targetTestExpo
     return conditions;
   } else if (typeof conditions === "object" && conditions !== null) {
     const { file, export: targetConditionExport } = conditions;
-    const modulePath = Path5.resolve(Path5.dirname(testFilePath), file);
+    const modulePath = Path4.resolve(Path4.dirname(testFilePath), file);
     const targetModule = await importModule(modulePath);
     const conditionArray = targetModule[targetConditionExport];
     if (Array.isArray(conditionArray)) {
@@ -10802,7 +11257,7 @@ var getResolvedTestConfig = async (testFilePath) => {
   if (!file) {
     throw new Error(`Invalid test configuration in ${testFilePath}`);
   }
-  const modulePath = Path5.resolve(Path5.dirname(testFilePath), file);
+  const modulePath = Path4.resolve(Path4.dirname(testFilePath), file);
   const targetModule = await importModule(modulePath);
   return {
     file,
@@ -10978,7 +11433,7 @@ var executeTestingCommand = async (testFiles, generateMode = false, report) => {
   const completeMessage = generateMode ? "Test generation complete." : "Testing complete.";
   try {
     for (const testFile of testFiles) {
-      const resolvedTestFile = Path5.resolve(testFile);
+      const resolvedTestFile = Path4.resolve(testFile);
       if (generateMode) {
         await generateTestsForFile(resolvedTestFile, report);
       } else {