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

package/api/index.js

@@ -4,11 +4,9 @@ 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 { v4 } from 'uuid';
 import Path from 'path';
-import FS from 'fs';
 import { fileURLToPath } from 'url';
-import { SyntaxKind, isLiteralTypeNode, isStringLiteral, isNumericLiteral, createSourceFile, ScriptTarget } from 'typescript';
-import { v4 } from 'uuid';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -3964,1433 +3962,1512 @@ var DATA_ITEM_DB_DRIVER_ERRORS = /* @__PURE__ */ ((DATA_ITEM_DB_DRIVER_ERRORS2)
   DATA_ITEM_DB_DRIVER_ERRORS2["SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED"] = "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED";
   return DATA_ITEM_DB_DRIVER_ERRORS2;
 })(DATA_ITEM_DB_DRIVER_ERRORS || {});
-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;
+// 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: {}
       }
-    }
-  }
-  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
-          );
-        });
+    },
+    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 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);
+    },
+    tags: {},
+    primaryField: "protocol"
+  },
+  Properties: {
+    fields: {
+      authSchemes: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        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: "authSchemes"
+  },
+  RetryStrategy: {
+    fields: {
+      mode: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: true,
+        tags: {}
+      },
+      retry: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        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);
+    },
+    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: {}
       }
-    } 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: "accessKeyId"
+  },
+  Signer: {
+    fields: {
+      sign: {
+        type: "string",
+        array: false,
+        readonly: false,
+        optional: false,
+        tags: {}
       }
-      typeInfo = {
-        ...typeInfo,
-        fields: {
-          ...existingFields,
-          ...nextFields
+    },
+    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
         }
-      };
-    }
-  }
-  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];
+      },
+      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: {}
       }
-    } else if (node.kind === SyntaxKind.UnionType) {
-      const { types } = node;
-      for (const type of types) {
-        values = [...values, ...getUnionOrLiteralStringValues(type)];
+    },
+    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 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) {
+// src/api/ORM/drivers/S3FileItemDBDriver.ts
+var S3FileItemDBDriver = class {
+  /**
+   * @param config Driver configuration including S3 settings.
+   */
+  constructor(config) {
+    this.config = config;
+    const { dbSpecificConfig } = config;
+    const { s3Config, bucketName, urlExpirationInSeconds } = dbSpecificConfig;
+    this.specificConfig = dbSpecificConfig;
+    this.s3 = new S3(s3Config);
+    this.s3FileDriver = new S3FileDriver({
+      s3Config,
+      bucketName,
+      urlExpirationInSeconds
+    });
+  }
+  specificConfig;
+  s3;
+  s3FileDriver;
+  /**
+   * Create a new @{@link BaseFileItem}.
+   * @param item New file item payload without the id field.
+   * @returns Generated file id.
+   * */
+  createItem = async (item) => {
+    const { tableName } = this.config;
+    const { bucketName } = this.specificConfig;
+    await this.s3.send(
+      new PutObjectCommand({
+        Bucket: bucketName,
+        Key: getFullFileKey({
+          file: item,
+          // SECURITY: `baseDirectory` is only used internally here, and not as part of the `id`.
+          baseDirectory: tableName
+        }),
+        Body: ""
+      })
+    );
+    return getFullFileKey({
+      file: item
+    });
+  };
+  /**
+   * Read a @{@link BaseFileItem} by its id.
+   * @param id Unique identifier value for the file.
+   * @param selectFields Optional fields to select from the file item.
+   * @returns File item payload (partial when selected fields are used).
+   * */
+  readItem = async (id, selectFields) => {
+    const { tableName } = this.config;
+    const { bucketName } = this.specificConfig;
+    if (typeof id === "undefined") {
+      throw new Error("MISSING_ID" /* MISSING_ID */);
+    } else {
+      const itemLoc = getBaseFileLocationInfo(id);
       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;
-        },
-        {}
+        ContentType = "",
+        ContentLength = 0,
+        LastModified} = await this.s3.send(
+        new HeadObjectCommand({
+          Bucket: bucketName,
+          Key: getFullFileKey({
+            file: itemLoc,
+            baseDirectory: tableName
+          })
+        })
       );
-      const cleanUnionFieldSets = existingUnionFieldSets ? existingUnionFieldSets.map(
-        (fieldSet) => fieldSet.filter(
-          (field) => picking ? omitFieldNames.includes(field) : !omitFieldNames.includes(field)
-        )
-      ) : void 0;
-      typeInfo = {
-        ...typeInfoOther,
-        fields: cleanTypeInfoFields,
-        unionFieldSets: cleanUnionFieldSets
+      const item = {
+        ...itemLoc,
+        id,
+        updatedOn: LastModified?.getTime() || 0,
+        mimeType: ContentType,
+        sizeInBytes: ContentLength,
+        isDirectory: ContentType === "application/x-directory",
+        uploadUrl: selectFields && selectFields.includes("uploadUrl") ? await this.s3FileDriver.getFileUploadUrl(itemLoc, tableName) : void 0,
+        downloadUrl: selectFields && selectFields.includes("downloadUrl") ? await this.s3FileDriver.getFileDownloadUrl(itemLoc, tableName) : void 0
       };
+      return item;
     }
-  }
-  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
-        };
-      }
-    }
-  }
-  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;
+  };
+  /**
+   * Update a @{@link BaseFileItem}.
+   * @param uniqueIdentifier Unique identifier value for the file.
+   * @param item Partial update payload for the file.
+   * @returns True when the item was updated.
+   * */
+  updateItem = async (uniqueIdentifier, item) => {
+    const { directory, name } = item;
+    const { tableName } = this.config;
+    const { bucketName } = this.specificConfig;
+    const oldItemLoc = getBaseFileLocationInfo(uniqueIdentifier);
+    const { name: oldName, directory: oldDirectory } = oldItemLoc;
+    if (name && (name !== oldName || directory !== oldDirectory)) {
+      await this.s3.send(
+        new CopyObjectCommand({
+          Bucket: bucketName,
+          Key: getFullFileKey({
+            file: {
+              directory,
+              name
+            },
+            baseDirectory: tableName
+          }),
+          CopySource: getFullFileKey({
+            file: oldItemLoc,
+            baseDirectory: tableName
+          })
+        })
+      );
+      await this.s3FileDriver.deleteFile(oldItemLoc, tableName);
     }
-    if (isPrimaryField) {
-      break;
+    await this.readItem(uniqueIdentifier);
+    return true;
+  };
+  /**
+   * Delete a @{@link BaseFileItem} by its id.
+   * @param id Unique identifier value for the file.
+   * @returns True when the item was deleted.
+   */
+  deleteItem = async (id) => {
+    const { tableName } = this.config;
+    if (typeof id === "undefined") {
+      throw new Error("MISSING_ID" /* MISSING_ID */);
+    } else {
+      await this.readItem(id);
+      await this.s3FileDriver.deleteFile(
+        getBaseFileLocationInfo(id),
+        tableName
+      );
     }
-  }
-  if (primaryFieldReadDenied) {
-    throw new Error(
-      "READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED" /* READ_DENIED_PRIMARY_FIELD_NOT_SUPPORTED */
+    return true;
+  };
+  /**
+   * List @{@link BaseFileItem}s by a given criteria.
+   * @param config List configuration and criteria.
+   * @param selectFields Optional fields to select from each file item.
+   * @returns List results with items and cursor.
+   */
+  listItems = async (config, selectFields) => {
+    const { tableName } = this.config;
+    const {
+      itemsPerPage = Infinity,
+      cursor,
+      sortFields = [],
+      criteria
+    } = config;
+    const { files: baseFileList = [], cursor: newCursor } = await this.s3FileDriver.listFiles(
+      void 0,
+      tableName,
+      itemsPerPage,
+      cursor
     );
+    const currentFileItems = baseFileList.map((bF) => ({
+      id: getFullFileKey({
+        file: bF
+      }),
+      ...bF
+    }));
+    const filteredFiles = criteria ? getFilterTypeInfoDataItemsBySearchCriteria(
+      criteria,
+      currentFileItems
+    ) : currentFileItems;
+    const expandedFiles = [];
+    for (const fF of filteredFiles) {
+      expandedFiles.push({
+        ...fF,
+        uploadUrl: selectFields?.includes("uploadUrl") ? await this.s3FileDriver.getFileUploadUrl(fF, tableName) : void 0,
+        downloadUrl: selectFields?.includes("downloadUrl") ? await this.s3FileDriver.getFileDownloadUrl(fF, tableName) : void 0
+      });
+    }
+    return {
+      items: getSortedItems(
+        sortFields,
+        expandedFiles
+      ),
+      cursor: newCursor
+    };
+  };
+};
+var S3SupportedFileItemDBDriverEntry = {
+  /**
+   * @param config Driver configuration.
+   * @returns S3 file driver instance.
+   */
+  factory: (config) => {
+    return new S3FileItemDBDriver(config);
+  },
+  /**
+   * @returns Type info pack for the S3 config.
+   */
+  getDBSpecificConfigTypeInfo: () => {
+    return {
+      entryTypeName: "S3SpecificConfig",
+      typeInfoMap: ConfigTypeInfoMap_default
+    };
   }
-  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;
+// 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
         }
-      });
-    }
-    if (outputTypeInfo) {
-      const typeInfo = getTypeInfoFromTypeAlias(typeAliasDec, typeMap);
-      if (typeInfo) {
-        typeInfoMap[key] = {
-          ...typeInfo,
-          primaryField: getPrimaryFieldForTypeInfo(typeInfo)
-        };
+      },
+      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"
   }
-  return typeInfoMap;
 };
 
-// src/common/TypeParsing/Validation.ts
-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"
+// src/api/ORM/drivers/DynamoDBDataItemDBDriver.ts
+typeof __dirname === "string" ? __dirname : Path.dirname(fileURLToPath(import.meta.url));
+var DynamoDBOperatorMappings = {
+  ["EQUALS" /* EQUALS */]: (fieldName) => `#${fieldName} = :${fieldName}`,
+  ["NOT_EQUALS" /* NOT_EQUALS */]: (fieldName) => `#${fieldName} <> :${fieldName}`,
+  ["GREATER_THAN" /* GREATER_THAN */]: (fieldName) => `#${fieldName} > :${fieldName}`,
+  ["GREATER_THAN_OR_EQUAL" /* GREATER_THAN_OR_EQUAL */]: (fieldName) => `#${fieldName} >= :${fieldName}`,
+  ["LESS_THAN" /* LESS_THAN */]: (fieldName) => `#${fieldName} < :${fieldName}`,
+  ["LESS_THAN_OR_EQUAL" /* LESS_THAN_OR_EQUAL */]: (fieldName) => `#${fieldName} <= :${fieldName}`,
+  ["IN" /* IN */]: (fieldName) => `#${fieldName} IN (:${fieldName})`,
+  ["LIKE" /* LIKE */]: (fieldName) => `contains(#${fieldName}, :${fieldName})`,
+  ["EXISTS" /* EXISTS */]: (fieldName) => `attribute_exists(#${fieldName})`,
+  ["NOT_EXISTS" /* NOT_EXISTS */]: (fieldName) => `attribute_not_exists(#${fieldName})`,
+  ["IS_EMPTY" /* IS_EMPTY */]: (fieldName) => `size(#${fieldName}) = 0`,
+  ["IS_NOT_EMPTY" /* IS_NOT_EMPTY */]: (fieldName) => `size(#${fieldName}) > 0`,
+  ["BETWEEN" /* BETWEEN */]: (fieldName) => `#${fieldName} BETWEEN :${fieldName}_start AND :${fieldName}_end`,
+  ["CONTAINS" /* CONTAINS */]: (fieldName) => `contains(#${fieldName}, :${fieldName})`,
+  ["STARTS_WITH" /* STARTS_WITH */]: (fieldName) => `begins_with(#${fieldName}, :${fieldName})`
 };
-var validateValueMatchesPattern = (typeName, value, pattern) => {
-  const results = {
-    typeName,
-    valid: true,
-    error: "",
-    errorMap: {}
-  };
-  {
-    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 DynamoDBLogicalOperatorMappings = {
+  ["AND" /* AND */]: "AND",
+  ["OR" /* OR */]: "OR"
 };
-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;
+var createFilterExpression = (fieldCriteria, logicalOperator) => {
+  let output = {};
+  if (fieldCriteria && fieldCriteria.length > 0) {
+    const expressions = [];
+    const attributeNames = {};
+    const attributeValues = {};
+    for (const criterion of fieldCriteria) {
+      const { fieldName, operator, value } = criterion;
+      const createExpression = DynamoDBOperatorMappings[operator];
+      if (!createExpression) {
+        throw {
+          message: "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED" /* SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED */,
+          operator,
+          fieldName
+        };
       }
+      expressions.push(createExpression(fieldName));
+      attributeNames[`#${fieldName}`] = fieldName;
+      attributeValues[`:${fieldName}`] = value;
     }
+    output = {
+      FilterExpression: expressions.join(
+        ` ${DynamoDBLogicalOperatorMappings[logicalOperator]} `
+      ),
+      ExpressionAttributeNames: attributeNames,
+      ExpressionAttributeValues: marshall(attributeValues)
+    };
   }
-  return valid;
+  return output;
 };
-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];
-      }
+var buildUpdateExpression = (updatedItem, uniquelyIdentifyingFieldName) => {
+  const updateExpressionParts = [];
+  const attributeNames = {};
+  const attributeValues = {};
+  for (const f in updatedItem) {
+    const value = updatedItem[f];
+    if (f !== uniquelyIdentifyingFieldName && typeof value !== "undefined") {
+      const placeholderName = `#${f}`;
+      const placeholderValue = `:${f}`;
+      updateExpressionParts.push(`${placeholderName} = ${placeholderValue}`);
+      attributeNames[placeholderName] = f;
+      attributeValues[placeholderValue] = marshall(value);
     }
   }
-  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: {}
+  return {
+    UpdateExpression: `SET ${updateExpressionParts.join(", ")}`,
+    ExpressionAttributeNames: attributeNames,
+    ExpressionAttributeValues: attributeValues
   };
-  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 buildSelectedFieldParams = (selectedFields) => {
+  const selectedFieldParams = typeof (selectedFields ?? false) && Array.isArray(selectedFields) ? {
+    ExpressionAttributeNames: selectedFields.reduce(
+      (acc, field) => {
+        const fieldAsString = String(field);
+        acc[`#${fieldAsString}`] = fieldAsString;
+        return acc;
+      },
+      {}
+    ),
+    ProjectionExpression: selectedFields.map((field) => `#${String(field)}`).join(", ")
+  } : {};
+  return selectedFieldParams;
 };
-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];
-      }
-    }
+var DynamoDBDataItemDBDriver = class {
+  /**
+   * @param config Driver configuration including DynamoDB client settings.
+   */
+  constructor(config) {
+    this.config = config;
+    const { dbSpecificConfig } = config;
+    this.dynamoDBClient = new DynamoDBClient(
+      dbSpecificConfig
+    );
   }
-  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/api/ORM/drivers/S3FileItemDBDriver.ts
-var moduleDirname = typeof __dirname === "string" ? __dirname : Path.dirname(fileURLToPath(import.meta.url));
-var S3FileItemDBDriver = class {
+  dynamoDBClient;
   /**
-   * @param config Driver configuration including S3 settings.
+   * Create an item in the database.
+   * @returns Generated identifier for the created item.
    */
-  constructor(config) {
-    this.config = config;
-    const { dbSpecificConfig } = config;
-    const { s3Config, bucketName, urlExpirationInSeconds } = dbSpecificConfig;
-    this.specificConfig = dbSpecificConfig;
-    this.s3 = new S3(s3Config);
-    this.s3FileDriver = new S3FileDriver({
-      s3Config,
-      bucketName,
-      urlExpirationInSeconds
+  createItem = async (newItem) => {
+    const {
+      tableName,
+      uniquelyIdentifyingFieldName,
+      generateUniqueIdentifier = () => v4()
+    } = this.config;
+    const newItemId = generateUniqueIdentifier(newItem);
+    const cleanNewItemWithId = {
+      ...newItem,
+      [uniquelyIdentifyingFieldName]: newItemId
+    };
+    const command = new PutItemCommand({
+      TableName: tableName,
+      Item: marshall(cleanNewItemWithId)
     });
-  }
-  specificConfig;
-  s3;
-  s3FileDriver;
+    await this.dynamoDBClient.send(command);
+    return newItemId;
+  };
   /**
-   * Create a new @{@link BaseFileItem}.
-   * @param item New file item payload without the id field.
-   * @returns Generated file id.
-   * */
-  createItem = async (item) => {
-    const { tableName } = this.config;
-    const { bucketName } = this.specificConfig;
-    await this.s3.send(
-      new PutObjectCommand({
-        Bucket: bucketName,
-        Key: getFullFileKey({
-          file: item,
-          // SECURITY: `baseDirectory` is only used internally here, and not as part of the `id`.
-          baseDirectory: tableName
-        }),
-        Body: ""
-      })
-    );
-    return getFullFileKey({
-      file: item
+   * Read an item from the database.
+   * @returns Item payload (partial when selected fields are used).
+   */
+  readItem = async (uniqueIdentifier, selectedFields) => {
+    const { tableName, uniquelyIdentifyingFieldName } = this.config;
+    const selectedFieldParams = buildSelectedFieldParams(selectedFields);
+    const command = new GetItemCommand({
+      TableName: tableName,
+      Key: marshall({
+        [uniquelyIdentifyingFieldName]: uniqueIdentifier
+      }),
+      ...selectedFieldParams
     });
+    const { Item } = await this.dynamoDBClient.send(command);
+    if (typeof Item === "undefined") {
+      throw new Error("ITEM_NOT_FOUND" /* ITEM_NOT_FOUND */);
+    } else {
+      const cleanItem = unmarshall(Item);
+      return cleanItem;
+    }
   };
   /**
-   * Read a @{@link BaseFileItem} by its id.
-   * @param id Unique identifier value for the file.
-   * @param selectFields Optional fields to select from the file item.
-   * @returns File item payload (partial when selected fields are used).
-   * */
-  readItem = async (id, selectFields) => {
-    const { tableName } = this.config;
-    const { bucketName } = this.specificConfig;
-    if (typeof id === "undefined") {
-      throw new Error("MISSING_ID" /* MISSING_ID */);
+   * Update an item in the database.
+   * @returns True when an item was updated.
+   */
+  updateItem = async (uniqueIdentifier, updatedItem) => {
+    const { tableName, uniquelyIdentifyingFieldName } = this.config;
+    const {
+      [uniquelyIdentifyingFieldName]: _unusedUniqueIdentifier,
+      ...cleanUpdatedItem
+    } = updatedItem;
+    if (typeof uniqueIdentifier !== "undefined") {
+      const command = new UpdateItemCommand({
+        TableName: tableName,
+        Key: marshall({
+          [uniquelyIdentifyingFieldName]: uniqueIdentifier
+        }),
+        ReturnValues: "ALL_NEW",
+        ...buildUpdateExpression(
+          cleanUpdatedItem,
+          uniquelyIdentifyingFieldName
+        )
+      });
+      const { Attributes } = await this.dynamoDBClient.send(command);
+      return !!Attributes;
     } else {
-      const itemLoc = getBaseFileLocationInfo(id);
-      const {
-        ContentType = "",
-        ContentLength = 0,
-        LastModified} = await this.s3.send(
-        new HeadObjectCommand({
-          Bucket: bucketName,
-          Key: getFullFileKey({
-            file: itemLoc,
-            baseDirectory: tableName
-          })
-        })
-      );
-      const item = {
-        ...itemLoc,
-        id,
-        updatedOn: LastModified?.getTime() || 0,
-        mimeType: ContentType,
-        sizeInBytes: ContentLength,
-        isDirectory: ContentType === "application/x-directory",
-        uploadUrl: selectFields && selectFields.includes("uploadUrl") ? await this.s3FileDriver.getFileUploadUrl(itemLoc, tableName) : void 0,
-        downloadUrl: selectFields && selectFields.includes("downloadUrl") ? await this.s3FileDriver.getFileDownloadUrl(itemLoc, tableName) : void 0
+      throw {
+        message: "MISSING_UNIQUE_IDENTIFIER" /* MISSING_UNIQUE_IDENTIFIER */,
+        uniquelyIdentifyingFieldName
       };
-      return item;
     }
   };
   /**
-   * Update a @{@link BaseFileItem}.
-   * @param uniqueIdentifier Unique identifier value for the file.
-   * @param item Partial update payload for the file.
-   * @returns True when the item was updated.
-   * */
-  updateItem = async (uniqueIdentifier, item) => {
-    const { directory, name } = item;
-    const { tableName } = this.config;
-    const { bucketName } = this.specificConfig;
-    const oldItemLoc = getBaseFileLocationInfo(uniqueIdentifier);
-    const { name: oldName, directory: oldDirectory } = oldItemLoc;
-    if (name && (name !== oldName || directory !== oldDirectory)) {
-      await this.s3.send(
-        new CopyObjectCommand({
-          Bucket: bucketName,
-          Key: getFullFileKey({
-            file: {
-              directory,
-              name
-            },
-            baseDirectory: tableName
-          }),
-          CopySource: getFullFileKey({
-            file: oldItemLoc,
-            baseDirectory: tableName
-          })
-        })
-      );
-      await this.s3FileDriver.deleteFile(oldItemLoc, tableName);
-    }
-    await this.readItem(uniqueIdentifier);
-    return true;
-  };
-  /**
-   * Delete a @{@link BaseFileItem} by its id.
-   * @param id Unique identifier value for the file.
-   * @returns True when the item was deleted.
-   */
-  deleteItem = async (id) => {
-    const { tableName } = this.config;
-    if (typeof id === "undefined") {
-      throw new Error("MISSING_ID" /* MISSING_ID */);
-    } else {
-      await this.readItem(id);
-      await this.s3FileDriver.deleteFile(
-        getBaseFileLocationInfo(id),
-        tableName
-      );
-    }
-    return true;
-  };
-  /**
-   * List @{@link BaseFileItem}s by a given criteria.
-   * @param config List configuration and criteria.
-   * @param selectFields Optional fields to select from each file item.
-   * @returns List results with items and cursor.
-   */
-  listItems = async (config, selectFields) => {
+   * Delete an item from the database.
+   * @returns True when an item was deleted.
+   */
+  deleteItem = async (uniqueIdentifier) => {
+    const { tableName, uniquelyIdentifyingFieldName } = this.config;
+    const command = new DeleteItemCommand({
+      TableName: tableName,
+      Key: marshall({
+        [uniquelyIdentifyingFieldName]: uniqueIdentifier
+      }),
+      ReturnValues: "ALL_OLD"
+    });
+    const { Attributes } = await this.dynamoDBClient.send(command);
+    return !!Attributes;
+  };
+  /**
+   * List items from the database.
+   * @returns List results with items and cursor.
+   */
+  listItems = async (config, selectedFields) => {
     const { tableName } = this.config;
     const {
-      itemsPerPage = Infinity,
+      itemsPerPage = 10,
       cursor,
-      sortFields = [],
-      criteria
+      sortFields,
+      criteria: {
+        logicalOperator = "AND" /* AND */,
+        fieldCriteria = []
+      } = {}
     } = config;
-    const { files: baseFileList = [], cursor: newCursor } = await this.s3FileDriver.listFiles(
-      void 0,
-      tableName,
-      itemsPerPage,
-      cursor
-    );
-    const currentFileItems = baseFileList.map((bF) => ({
-      id: getFullFileKey({
-        file: bF
-      }),
-      ...bF
-    }));
-    const filteredFiles = criteria ? getFilterTypeInfoDataItemsBySearchCriteria(
-      criteria,
-      currentFileItems
-    ) : currentFileItems;
-    const expandedFiles = [];
-    for (const fF of filteredFiles) {
-      expandedFiles.push({
-        ...fF,
-        uploadUrl: selectFields?.includes("uploadUrl") ? await this.s3FileDriver.getFileUploadUrl(fF, tableName) : void 0,
-        downloadUrl: selectFields?.includes("downloadUrl") ? await this.s3FileDriver.getFileDownloadUrl(fF, tableName) : void 0
-      });
+    const {
+      ProjectionExpression,
+      ExpressionAttributeNames: selectFieldParamsAttributeNames
+    } = buildSelectedFieldParams(selectedFields);
+    const {
+      FilterExpression,
+      ExpressionAttributeNames,
+      ExpressionAttributeValues
+    } = createFilterExpression(fieldCriteria, logicalOperator);
+    const params = {
+      TableName: tableName,
+      Select: selectedFields && selectedFields.length > 0 ? "SPECIFIC_ATTRIBUTES" : "ALL_ATTRIBUTES",
+      ...ProjectionExpression ? {
+        ProjectionExpression
+      } : {},
+      ...FilterExpression ? {
+        FilterExpression
+      } : {},
+      ...FilterExpression ? {
+        ExpressionAttributeNames: {
+          ...selectFieldParamsAttributeNames,
+          ...ExpressionAttributeNames
+        }
+      } : ProjectionExpression ? {
+        ExpressionAttributeNames: {
+          ...selectFieldParamsAttributeNames
+        }
+      } : {},
+      ...FilterExpression ? {
+        ExpressionAttributeValues
+      } : {}
+    };
+    let structuredCursor = void 0;
+    if (typeof cursor === "string") {
+      try {
+        structuredCursor = marshall(JSON.parse(cursor));
+      } catch (error) {
+        throw {
+          message: "INVALID_CURSOR" /* INVALID_CURSOR */,
+          cursor
+        };
+      }
     }
+    const command = new ScanCommand({
+      ...params,
+      ExclusiveStartKey: structuredCursor,
+      Limit: itemsPerPage
+    });
+    const { Items = [], LastEvaluatedKey } = await this.dynamoDBClient.send(command);
+    const unmarshalledItems = Items.map((item) => unmarshall(item));
+    const sortedItems = getSortedItems(sortFields, unmarshalledItems);
     return {
-      items: getSortedItems(
-        sortFields,
-        expandedFiles
-      ),
-      cursor: newCursor
+      items: sortedItems,
+      cursor: LastEvaluatedKey ? JSON.stringify(unmarshall(LastEvaluatedKey)) : void 0
     };
   };
 };
-var S3SupportedFileItemDBDriverEntry = {
+var DynamoDBSupportedDataItemDBDriverEntry = {
   /**
    * @param config Driver configuration.
-   * @returns S3 file driver instance.
+   * @returns DynamoDB-backed driver instance.
    */
   factory: (config) => {
-    return new S3FileItemDBDriver(config);
+    return new DynamoDBDataItemDBDriver(config);
   },
   /**
-   * @returns Type info pack for the S3 config.
+   * @returns Type info pack for the DynamoDB-specific config.
    */
   getDBSpecificConfigTypeInfo: () => {
-    const configTypesPath = Path.join(
-      moduleDirname,
-      "S3FileItemDBDriver",
-      "ConfigTypes.ts"
-    );
-    const configTypesTS = FS.readFileSync(configTypesPath, "utf8");
-    const typeInfoMap = getTypeInfoMapFromTypeScript(configTypesTS);
     return {
-      entryTypeName: "S3SpecificConfig",
-      typeInfoMap
+      entryTypeName: "DynamoDBSpecificConfig",
+      typeInfoMap: ConfigTypeInfoMap_default2
     };
   }
 };
-var moduleDirname2 = typeof __dirname === "string" ? __dirname : Path.dirname(fileURLToPath(import.meta.url));
-var DynamoDBOperatorMappings = {
-  ["EQUALS" /* EQUALS */]: (fieldName) => `#${fieldName} = :${fieldName}`,
-  ["NOT_EQUALS" /* NOT_EQUALS */]: (fieldName) => `#${fieldName} <> :${fieldName}`,
-  ["GREATER_THAN" /* GREATER_THAN */]: (fieldName) => `#${fieldName} > :${fieldName}`,
-  ["GREATER_THAN_OR_EQUAL" /* GREATER_THAN_OR_EQUAL */]: (fieldName) => `#${fieldName} >= :${fieldName}`,
-  ["LESS_THAN" /* LESS_THAN */]: (fieldName) => `#${fieldName} < :${fieldName}`,
-  ["LESS_THAN_OR_EQUAL" /* LESS_THAN_OR_EQUAL */]: (fieldName) => `#${fieldName} <= :${fieldName}`,
-  ["IN" /* IN */]: (fieldName) => `#${fieldName} IN (:${fieldName})`,
-  ["LIKE" /* LIKE */]: (fieldName) => `contains(#${fieldName}, :${fieldName})`,
-  ["EXISTS" /* EXISTS */]: (fieldName) => `attribute_exists(#${fieldName})`,
-  ["NOT_EXISTS" /* NOT_EXISTS */]: (fieldName) => `attribute_not_exists(#${fieldName})`,
-  ["IS_EMPTY" /* IS_EMPTY */]: (fieldName) => `size(#${fieldName}) = 0`,
-  ["IS_NOT_EMPTY" /* IS_NOT_EMPTY */]: (fieldName) => `size(#${fieldName}) > 0`,
-  ["BETWEEN" /* BETWEEN */]: (fieldName) => `#${fieldName} BETWEEN :${fieldName}_start AND :${fieldName}_end`,
-  ["CONTAINS" /* CONTAINS */]: (fieldName) => `contains(#${fieldName}, :${fieldName})`,
-  ["STARTS_WITH" /* STARTS_WITH */]: (fieldName) => `begins_with(#${fieldName}, :${fieldName})`
-};
-var DynamoDBLogicalOperatorMappings = {
-  ["AND" /* AND */]: "AND",
-  ["OR" /* OR */]: "OR"
+
+// src/api/ORM/drivers/InMemoryDataItemDBDriver/ConfigTypeInfoMap.json
+var ConfigTypeInfoMap_default3 = {
+  InMemorySpecificConfig: {
+    fields: {},
+    tags: {}
+  }
 };
-var createFilterExpression = (fieldCriteria, logicalOperator) => {
-  let output = {};
-  if (fieldCriteria && fieldCriteria.length > 0) {
-    const expressions = [];
-    const attributeNames = {};
-    const attributeValues = {};
-    for (const criterion of fieldCriteria) {
-      const { fieldName, operator, value } = criterion;
-      const createExpression = DynamoDBOperatorMappings[operator];
-      if (!createExpression) {
-        throw {
-          message: "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED" /* SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED */,
-          operator,
-          fieldName
-        };
-      }
-      expressions.push(createExpression(fieldName));
-      attributeNames[`#${fieldName}`] = fieldName;
-      attributeValues[`:${fieldName}`] = value;
+
+// src/api/ORM/drivers/InMemoryDataItemDBDriver.ts
+typeof __dirname === "string" ? __dirname : Path.dirname(fileURLToPath(import.meta.url));
+var decodeCursor2 = (cursor) => {
+  if (!cursor) {
+    return 0;
+  }
+  try {
+    const parsed = JSON.parse(cursor);
+    const offset = parsed.offset ?? 0;
+    if (!Number.isFinite(offset) || offset < 0) {
+      throw new Error("Invalid cursor offset.");
     }
-    output = {
-      FilterExpression: expressions.join(
-        ` ${DynamoDBLogicalOperatorMappings[logicalOperator]} `
-      ),
-      ExpressionAttributeNames: attributeNames,
-      ExpressionAttributeValues: marshall(attributeValues)
+    return offset;
+  } catch (_error) {
+    throw {
+      message: "INVALID_CURSOR" /* INVALID_CURSOR */,
+      cursor
     };
   }
-  return output;
 };
-var buildUpdateExpression = (updatedItem, uniquelyIdentifyingFieldName) => {
-  const updateExpressionParts = [];
-  const attributeNames = {};
-  const attributeValues = {};
-  for (const f in updatedItem) {
-    const value = updatedItem[f];
-    if (f !== uniquelyIdentifyingFieldName && typeof value !== "undefined") {
-      const placeholderName = `#${f}`;
-      const placeholderValue = `:${f}`;
-      updateExpressionParts.push(`${placeholderName} = ${placeholderValue}`);
-      attributeNames[placeholderName] = f;
-      attributeValues[placeholderValue] = marshall(value);
-    }
+var encodeCursor2 = (offset) => JSON.stringify({ offset });
+var selectFieldsFromItem = (item, selectedFields) => {
+  if (!selectedFields || selectedFields.length === 0) {
+    return { ...item };
   }
-  return {
-    UpdateExpression: `SET ${updateExpressionParts.join(", ")}`,
-    ExpressionAttributeNames: attributeNames,
-    ExpressionAttributeValues: attributeValues
-  };
-};
-var buildSelectedFieldParams = (selectedFields) => {
-  const selectedFieldParams = typeof (selectedFields ?? false) && Array.isArray(selectedFields) ? {
-    ExpressionAttributeNames: selectedFields.reduce(
-      (acc, field) => {
-        const fieldAsString = String(field);
-        acc[`#${fieldAsString}`] = fieldAsString;
-        return acc;
-      },
-      {}
-    ),
-    ProjectionExpression: selectedFields.map((field) => `#${String(field)}`).join(", ")
-  } : {};
-  return selectedFieldParams;
+  return selectedFields.reduce((accumulator, field) => {
+    if (field in item) {
+      accumulator[field] = item[field];
+    }
+    return accumulator;
+  }, {});
 };
-var DynamoDBDataItemDBDriver = class {
-  /**
-   * @param config Driver configuration including DynamoDB client settings.
-   */
-  constructor(config) {
-    this.config = config;
-    const { dbSpecificConfig } = config;
-    this.dynamoDBClient = new DynamoDBClient(
-      dbSpecificConfig
-    );
-  }
-  dynamoDBClient;
-  /**
-   * Create an item in the database.
-   * @returns Generated identifier for the created item.
-   */
-  createItem = async (newItem) => {
-    const {
-      tableName,
-      uniquelyIdentifyingFieldName,
-      generateUniqueIdentifier = () => v4()
-    } = this.config;
-    const newItemId = generateUniqueIdentifier(newItem);
-    const cleanNewItemWithId = {
-      ...newItem,
-      [uniquelyIdentifyingFieldName]: newItemId
-    };
-    const command = new PutItemCommand({
-      TableName: tableName,
-      Item: marshall(cleanNewItemWithId)
-    });
-    await this.dynamoDBClient.send(command);
-    return newItemId;
-  };
-  /**
-   * Read an item from the database.
-   * @returns Item payload (partial when selected fields are used).
-   */
-  readItem = async (uniqueIdentifier, selectedFields) => {
-    const { tableName, uniquelyIdentifyingFieldName } = this.config;
-    const selectedFieldParams = buildSelectedFieldParams(selectedFields);
-    const command = new GetItemCommand({
-      TableName: tableName,
-      Key: marshall({
-        [uniquelyIdentifyingFieldName]: uniqueIdentifier
-      }),
-      ...selectedFieldParams
-    });
-    const { Item } = await this.dynamoDBClient.send(command);
-    if (typeof Item === "undefined") {
-      throw new Error("ITEM_NOT_FOUND" /* ITEM_NOT_FOUND */);
-    } else {
-      const cleanItem = unmarshall(Item);
-      return cleanItem;
-    }
-  };
-  /**
-   * Update an item in the database.
-   * @returns True when an item was updated.
-   */
-  updateItem = async (uniqueIdentifier, updatedItem) => {
-    const { tableName, uniquelyIdentifyingFieldName } = this.config;
-    const {
-      [uniquelyIdentifyingFieldName]: _unusedUniqueIdentifier,
-      ...cleanUpdatedItem
-    } = updatedItem;
-    if (typeof uniqueIdentifier !== "undefined") {
-      const command = new UpdateItemCommand({
-        TableName: tableName,
-        Key: marshall({
-          [uniquelyIdentifyingFieldName]: uniqueIdentifier
-        }),
-        ReturnValues: "ALL_NEW",
-        ...buildUpdateExpression(
-          cleanUpdatedItem,
-          uniquelyIdentifyingFieldName
-        )
-      });
-      const { Attributes } = await this.dynamoDBClient.send(command);
-      return !!Attributes;
-    } else {
-      throw {
-        message: "MISSING_UNIQUE_IDENTIFIER" /* MISSING_UNIQUE_IDENTIFIER */,
-        uniquelyIdentifyingFieldName
-      };
-    }
-  };
-  /**
-   * Delete an item from the database.
-   * @returns True when an item was deleted.
-   */
-  deleteItem = async (uniqueIdentifier) => {
-    const { tableName, uniquelyIdentifyingFieldName } = this.config;
-    const command = new DeleteItemCommand({
-      TableName: tableName,
-      Key: marshall({
-        [uniquelyIdentifyingFieldName]: uniqueIdentifier
-      }),
-      ReturnValues: "ALL_OLD"
-    });
-    const { Attributes } = await this.dynamoDBClient.send(command);
-    return !!Attributes;
-  };
-  /**
-   * List items from the database.
-   * @returns List results with items and cursor.
-   */
-  listItems = async (config, selectedFields) => {
-    const { tableName } = this.config;
-    const {
-      itemsPerPage = 10,
-      cursor,
-      sortFields,
-      criteria: {
-        logicalOperator = "AND" /* AND */,
-        fieldCriteria = []
-      } = {}
-    } = config;
-    const {
-      ProjectionExpression,
-      ExpressionAttributeNames: selectFieldParamsAttributeNames
-    } = buildSelectedFieldParams(selectedFields);
-    const {
-      FilterExpression,
-      ExpressionAttributeNames,
-      ExpressionAttributeValues
-    } = createFilterExpression(fieldCriteria, logicalOperator);
-    const params = {
-      TableName: tableName,
-      Select: selectedFields && selectedFields.length > 0 ? "SPECIFIC_ATTRIBUTES" : "ALL_ATTRIBUTES",
-      ...ProjectionExpression ? {
-        ProjectionExpression
-      } : {},
-      ...FilterExpression ? {
-        FilterExpression
-      } : {},
-      ...FilterExpression ? {
-        ExpressionAttributeNames: {
-          ...selectFieldParamsAttributeNames,
-          ...ExpressionAttributeNames
-        }
-      } : ProjectionExpression ? {
-        ExpressionAttributeNames: {
-          ...selectFieldParamsAttributeNames
-        }
-      } : {},
-      ...FilterExpression ? {
-        ExpressionAttributeValues
-      } : {}
-    };
-    let structuredCursor = void 0;
-    if (typeof cursor === "string") {
-      try {
-        structuredCursor = marshall(JSON.parse(cursor));
-      } catch (error) {
-        throw {
-          message: "INVALID_CURSOR" /* INVALID_CURSOR */,
-          cursor
-        };
-      }
-    }
-    const command = new ScanCommand({
-      ...params,
-      ExclusiveStartKey: structuredCursor,
-      Limit: itemsPerPage
-    });
-    const { Items = [], LastEvaluatedKey } = await this.dynamoDBClient.send(command);
-    const unmarshalledItems = Items.map((item) => unmarshall(item));
-    const sortedItems = getSortedItems(sortFields, unmarshalledItems);
-    return {
-      items: sortedItems,
-      cursor: LastEvaluatedKey ? JSON.stringify(unmarshall(LastEvaluatedKey)) : void 0
-    };
-  };
-};
-var DynamoDBSupportedDataItemDBDriverEntry = {
-  /**
-   * @param config Driver configuration.
-   * @returns DynamoDB-backed driver instance.
-   */
-  factory: (config) => {
-    return new DynamoDBDataItemDBDriver(config);
-  },
-  /**
-   * @returns Type info pack for the DynamoDB-specific config.
-   */
-  getDBSpecificConfigTypeInfo: () => {
-    const configTypesPath = Path.join(
-      moduleDirname2,
-      "DynamoDBDataItemDBDriver",
-      "ConfigTypes.ts"
-    );
-    const configTypesTS = FS.readFileSync(configTypesPath, "utf8");
-    const typeInfoMap = getTypeInfoMapFromTypeScript(configTypesTS);
-    return {
-      entryTypeName: "DynamoDBSpecificConfig",
-      typeInfoMap
-    };
-  }
-};
-var moduleDirname3 = typeof __dirname === "string" ? __dirname : Path.dirname(fileURLToPath(import.meta.url));
-var decodeCursor2 = (cursor) => {
-  if (!cursor) {
-    return 0;
-  }
-  try {
-    const parsed = JSON.parse(cursor);
-    const offset = parsed.offset ?? 0;
-    if (!Number.isFinite(offset) || offset < 0) {
-      throw new Error("Invalid cursor offset.");
-    }
-    return offset;
-  } catch (_error) {
-    throw {
-      message: "INVALID_CURSOR" /* INVALID_CURSOR */,
-      cursor
-    };
-  }
-};
-var encodeCursor2 = (offset) => JSON.stringify({ offset });
-var selectFieldsFromItem = (item, selectedFields) => {
-  if (!selectedFields || selectedFields.length === 0) {
-    return { ...item };
-  }
-  return selectedFields.reduce((accumulator, field) => {
-    if (field in item) {
-      accumulator[field] = item[field];
-    }
-    return accumulator;
-  }, {});
-};
-var InMemoryDataItemDBDriver = class {
+var InMemoryDataItemDBDriver = class {
   constructor(config) {
     this.config = config;
   }
@@ -5405,7 +5482,9 @@ var InMemoryDataItemDBDriver = class {
       uniquelyIdentifyingFieldName,
       generateUniqueIdentifier = () => v4()
     } = this.config;
-    const newItemId = generateUniqueIdentifier(newItem);
+    const newItemId = generateUniqueIdentifier(
+      newItem
+    );
     const cleanNewItemWithId = {
       ...newItem,
       [uniquelyIdentifyingFieldName]: newItemId
@@ -5477,18 +5556,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;
@@ -5510,16 +5587,9 @@ var InMemorySupportedDataItemDBDriverEntry = {
    * @returns Type info pack for the in-memory config.
    */
   getDBSpecificConfigTypeInfo: () => {
-    const configTypesPath = Path.join(
-      moduleDirname3,
-      "InMemoryDataItemDBDriver",
-      "ConfigTypes.ts"
-    );
-    const configTypesTS = FS.readFileSync(configTypesPath, "utf8");
-    const typeInfoMap = getTypeInfoMapFromTypeScript(configTypesTS);
     return {
       entryTypeName: "InMemorySpecificConfig",
-      typeInfoMap
+      typeInfoMap: ConfigTypeInfoMap_default3
     };
   }
 };
@@ -5551,7 +5621,33 @@ var InMemoryItemRelationshipDBDriver = class extends InMemoryDataItemDBDriver {
     });
   }
 };
-var moduleDirname4 = typeof __dirname === "string" ? __dirname : Path.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 : Path.dirname(fileURLToPath(import.meta.url));
 var decodeCursor3 = (cursor) => {
   if (!cursor) {
     return 0;
@@ -5607,13 +5703,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 = {
@@ -5719,7 +5816,10 @@ var InMemoryFileItemDBDriver = class {
       criteria,
       allItems
     ) : allItems;
-    const sortedItems = getSortedItems(sortFields, filteredItems);
+    const sortedItems = getSortedItems(
+      sortFields,
+      filteredItems
+    );
     const offset = decodeCursor3(cursor);
     const slice = sortedItems.slice(offset, offset + itemsPerPage);
     const expandedItems = slice.map((item) => {
@@ -5751,16 +5851,9 @@ var InMemoryFileSupportedDataItemDBDriverEntry = {
    * @returns Type info pack for the in-memory file config.
    */
   getDBSpecificConfigTypeInfo: () => {
-    const configTypesPath = Path.join(
-      moduleDirname4,
-      "InMemoryFileItemDBDriver",
-      "ConfigTypes.ts"
-    );
-    const configTypesTS = FS.readFileSync(configTypesPath, "utf8");
-    const typeInfoMap = getTypeInfoMapFromTypeScript(configTypesTS);
     return {
       entryTypeName: "InMemoryFileSpecificConfig",
-      typeInfoMap
+      typeInfoMap: ConfigTypeInfoMap_default4
     };
   }
 };
@@ -5879,6 +5972,343 @@ var SUPPORTED_TYPE_INFO_ORM_DB_DRIVERS = {
   ["S3_FILE_ITEM" /* S3_FILE_ITEM */]: S3SupportedFileItemDBDriverEntry
 };
 
+// src/common/TypeParsing/Validation.ts
+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: {}
+  };
+  {
+    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/SearchValidation.ts
 var SEARCH_VALIDATION_ERRORS = {
   INVALID_TYPE_INFO: "INVALID_TYPE_INFO",