@conduit-client/model 3.7.0 → 3.8.0

package/dist/v1/index.js

@@ -3,9 +3,9 @@
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-import path from "path";
-import amf from "amf-client-js";
 import * as url from "url";
+import amf from "amf-client-js";
+import path from "path";
 const BindingTypesEnum = ["wire", "imperative", "imperative-legacy", "mutation"];
 class BaseTypeRegistry extends Map {
   nameOf(t) {
@@ -336,7 +336,11 @@ function isTypeUsableAsKey(type, seenTypes = /* @__PURE__ */ new Set()) {
   return result;
 }
 function isNullableType(type) {
-  const concreteType = getConcreteTypeFromRef(type);
+  const concreteTypeResult = getConcreteTypeFromRef(type);
+  if (concreteTypeResult.isErr()) {
+    return void 0;
+  }
+  const concreteType = concreteTypeResult.value;
   if (isNilType(concreteType)) {
     return true;
   } else if (isOneOfType(concreteType)) {
@@ -348,10 +352,15 @@ function isNullableType(type) {
 }
 function getConcreteTypeFromRef(type) {
   let concreteType = type;
+  let seenTypes = /* @__PURE__ */ new Set();
   while (isRefType(concreteType)) {
+    if (seenTypes.has(concreteType)) {
+      return err({ type: concreteType, seenTypes });
+    }
+    seenTypes.add(concreteType);
     concreteType = concreteType.$ref;
   }
-  return concreteType;
+  return ok(concreteType);
 }
 class KeySourcesValidator {
   constructor(types, sources) {
@@ -507,9 +516,29 @@ class KeySourcesValidator {
     return result ? ok(messages) : err(messages);
   }
   validateAccessors(type, propName, accessors) {
-    const concreteType = getConcreteTypeFromRef(type);
+    const concreteTypeResult = getConcreteTypeFromRef(type);
+    if (concreteTypeResult.isErr()) {
+      return err([
+        getFormattedMessage$1(
+          type,
+          `Unwrapping refs for type "${this.getNameOf(concreteTypeResult.error.type)}" led to the following types in an infinite loop: [${Array.from(
+            concreteTypeResult.error.seenTypes
+          ).map((t) => this.getNameOf(t)).join(", ")}].`
+        )
+      ]);
+    }
+    const concreteType = concreteTypeResult.value;
     if (isOneOfType(concreteType) || isAllOfType(concreteType) || isDiscriminatedObjectType(concreteType) || isObjectType(concreteType)) {
-      if (isNullableType(concreteType)) {
+      const isNullable = isNullableType(concreteType);
+      if (isNullable === void 0) {
+        return err([
+          getFormattedMessage$1(
+            type,
+            `Unwrapping refs for type "${this.getNameOf(concreteType)}" led to an infinite loop.`
+          )
+        ]);
+      }
+      if (isNullable) {
         return err([
           getFormattedMessage$1(
             concreteType,
@@ -940,58 +969,322 @@ class InvalidationValidator {
     return null;
   }
 }
-var util;
-(function(util2) {
-  util2.assertEqual = (val) => val;
-  function assertIs(_arg) {
-  }
-  util2.assertIs = assertIs;
-  function assertNever(_x) {
-    throw new Error();
-  }
-  util2.assertNever = assertNever;
-  util2.arrayToEnum = (items) => {
-    const obj = {};
-    for (const item of items) {
-      obj[item] = item;
-    }
-    return obj;
+const V1_VERSION = "1.0.0";
+const ANONYMOUS_TYPE_NAME = "<anonymous>";
+function asAPIService(api) {
+  const p = Promise.resolve(api);
+  return {
+    build: () => p,
+    api
   };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-    const filtered = {};
-    for (const k of validKeys) {
-      filtered[k] = obj[k];
+}
+class NoNormalizedTypesValidator {
+  constructor(types) {
+    this.types = types;
+  }
+  validate(operation) {
+    if (isNormalizedOperation(operation)) {
+      return ok([]);
     }
-    return util2.objectValues(filtered);
-  };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
-      return obj[e];
+    const identifiableTypes = /* @__PURE__ */ new Set();
+    operation.responses.forEach((response) => {
+      return response.payloads.forEach((payload) => {
+        this.findNestedIdentifiableTypes(payload.data).forEach(
+          (type) => identifiableTypes.add(type)
+        );
+      });
     });
-  };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
-    const keys = [];
-    for (const key in object) {
-      if (Object.prototype.hasOwnProperty.call(object, key)) {
-        keys.push(key);
+    const messages = [];
+    if (identifiableTypes.size > 0) {
+      identifiableTypes.forEach((type) => {
+        const typeName = this.types.nameOf(type) || ANONYMOUS_TYPE_NAME;
+        messages.push(
+          getFormattedMessage(
+            operation,
+            `Operation ${operation.operationId ? `${operation.operationId} ` : ``}is not normalized but references the normalized type ${typeName} in its response`
+          )
+        );
+      });
+      return messages.length === 0 ? ok([]) : err(messages);
+    }
+    return ok([]);
+  }
+  /**
+   * Completes a breadth-first search of a Type to locate any nested types that are identifiable.
+   *
+   * @returns a Set of all nested types that are identifiable.
+   * @param start
+   * @protected
+   */
+  findNestedIdentifiableTypes(start) {
+    return bfs(
+      [start],
+      (type) => {
+        var _a;
+        return ((_a = type.extensions) == null ? void 0 : _a.type) === "identifiable";
+      },
+      (type) => {
+        const typing = type.type;
+        switch (typing) {
+          case "allOf":
+            return type.allOf;
+          case "array":
+            return [type.items];
+          case "object":
+            return [
+              ...Object.values(type.properties).map((property) => property.type),
+              type.additionalProperties
+            ];
+          case "oneOf":
+            return type.oneOf;
+          case "ref":
+            return [type.$ref];
+          case "discriminatedObject":
+            return [...Object.values(type.mapping), type.baseType];
+          case "any":
+          case "enum":
+          case "boolean":
+          case "double":
+          case "integer":
+          case "number":
+          case "string":
+          case "date":
+          case "datetime":
+          case "datetime-only":
+          case "nil":
+          case "not":
+          case "time":
+            return [];
+          default:
+            throw new Error(
+              `${typing} has not been accounted for when searching for nested identifiable types`
+            );
+        }
       }
+    );
+  }
+}
+class KeyMatchValidator {
+  constructor(types) {
+    this.types = types;
+  }
+  validate(operation) {
+    if (!isNormalizedOperation(operation)) {
+      return ok([]);
     }
-    return keys;
+    const operationHasKey = !!operation.cacheStrategy.key;
+    let valid = true;
+    const messages = [];
+    operation.responses.forEach((response) => {
+      response.payloads.forEach((payload) => {
+        var _a, _b;
+        if (((_a = payload.data.extensions) == null ? void 0 : _a.type) === "identifiable") {
+          const typeName = this.types.nameOf(payload.data) || ANONYMOUS_TYPE_NAME;
+          if (!operationHasKey) {
+            valid = false;
+            messages.push(
+              getFormattedMessage(
+                operation,
+                `Operation ${operation.operationId ? `${operation.operationId} ` : ``}is missing a key to match against its ${typeName} response type`
+              )
+            );
+          } else if (!((_b = payload.data.extensions.key) == null ? void 0 : _b.fields)) {
+            valid = false;
+            messages.push(
+              getFormattedMessage(
+                operation,
+                `Operation ${operation.operationId ? `${operation.operationId} ` : ``}has a key but its ${typeName} response type doesn't have one to match against`
+              )
+            );
+          } else if (!deepEquals(
+            Object.keys(operation.cacheStrategy.key || {}),
+            Object.keys(payload.data.extensions.key.fields)
+          )) {
+            valid = false;
+            messages.push(
+              getFormattedMessage(
+                operation,
+                `Operation ${operation.operationId ? `${operation.operationId} ` : ``}and its ${typeName} response type have mismatched keys`
+              )
+            );
+          }
+        }
+      });
+    });
+    return valid ? ok(messages) : err(messages);
+  }
+}
+class BodyDataValidator {
+  constructor(target, keys, keySourcesValidatorSupplier) {
+    this.target = target;
+    this.keys = keys;
+    this.keySourcesValidatorSupplier = keySourcesValidatorSupplier;
+  }
+  validate(operation) {
+    if (this.keys.length === 0) {
+      return ok([]);
+    }
+    const jsonPayload = this.target.payloads.find((p) => p.mediaType === "application/json");
+    if (jsonPayload === void 0) {
+      return err([
+        getFormattedMessage(
+          operation,
+          `Use of 'body' keys requires a json payload: ${operation.method} ${operation.endpoint.path} has none.`
+        )
+      ]);
+    }
+    const result = this.keySourcesValidatorSupplier(this.keys).validate(jsonPayload.data);
+    if (!result.isOk()) {
+      const message = getFormattedMessage(
+        operation,
+        `Invalid body key(s) specified for ${operation.operationId || `${operation.method} ${operation.endpoint.path}`}`
+      );
+      message.subValidationMessages = result.error;
+      return err([message]);
+    }
+    return ok([]);
+  }
+}
+function buildOperationValidator(api) {
+  const bodyDateValidatorSupplier = (target, sources) => {
+    return new BodyDataValidator(target, sources, (keys) => {
+      return new KeySourcesValidator(api.types, keys);
+    });
   };
-  util2.find = (arr, checker) => {
-    for (const item of arr) {
-      if (checker(item))
-        return item;
+  return compose([
+    new InvalidationValidator(api.types, bodyDateValidatorSupplier),
+    new KeySourceValidator(bodyDateValidatorSupplier),
+    new Response200Validator(),
+    new NoNormalizedTypesValidator(api.types),
+    new KeyMatchValidator(api.types)
+  ]);
+}
+function buildEndpointValidator(api) {
+  const operationValidator = buildOperationValidator(api);
+  return {
+    validate(subject) {
+      return combineValidationResults(
+        subject.operations.map((operation) => operationValidator.validate(operation))
+      );
     }
-    return void 0;
   };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
-  function joinValues(array, separator = " | ") {
-    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+}
+class BindingsValidation {
+  constructor() {
   }
-  util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_, value) => {
+  validate(api) {
+    const messages = [];
+    const endpoints = api.endpoints;
+    const identToPathAndOperation = /* @__PURE__ */ new Map();
+    for (const endpoint of endpoints) {
+      const { path: path2, operations } = endpoint;
+      for (const operation of operations) {
+        const operationId = operation.operationId || `${operation.method} ${operation.endpoint.path}`;
+        const { bindings } = operation;
+        for (const binding of bindings) {
+          const { identifier } = binding;
+          if (identToPathAndOperation.has(identifier)) {
+            const existing = identToPathAndOperation.get(identifier);
+            messages.push({
+              severity: ValidationSeverity.Error,
+              message: `Binding identifier '${identifier}' in operation '${operationId}' is already used in path '${existing.path}' and operation '${existing.operationId}'`,
+              subject: operation,
+              validationType: ValidationType.Operation
+            });
+          } else {
+            identToPathAndOperation.set(identifier, { path: path2, operationId });
+          }
+        }
+      }
+    }
+    return messages.length > 0 ? err(messages) : ok(messages);
+  }
+}
+class ApiValidator {
+  constructor(apiValidators, typeValidator, endpointValidator) {
+    this.apiValidators = apiValidators;
+    this.typeValidator = typeValidator;
+    this.endpointValidator = endpointValidator;
+  }
+  validate(subject) {
+    const results = [
+      this.validateCollection(subject.types.values(), this.typeValidator),
+      this.validateCollection(subject.endpoints, this.endpointValidator),
+      ...this.apiValidators.map((v) => v.validate(subject))
+    ];
+    return combineValidationResults(results);
+  }
+  validateCollection(items, validator) {
+    const results = [];
+    for (const item of items) {
+      results.push(validator.validate(item));
+    }
+    return combineValidationResults(results);
+  }
+}
+function buildApiValidatorFor(api) {
+  const typeValidation = buildTypeValidator(api.types);
+  const apiValidators = [new BindingsValidation()];
+  const endpointValidation = buildEndpointValidator(api);
+  return new ApiValidator(apiValidators, typeValidation, endpointValidation);
+}
+function validateUniqueBindingIdentfiers(operations) {
+  const operationsBindings = operations.map(({ bindings }) => bindings.map(({ identifier }) => identifier)).flat();
+  const uniqueBindings = new Set(operationsBindings);
+  return operationsBindings.length === uniqueBindings.size;
+}
+var util;
+(function(util2) {
+  util2.assertEqual = (val) => val;
+  function assertIs(_arg) {
+  }
+  util2.assertIs = assertIs;
+  function assertNever(_x) {
+    throw new Error();
+  }
+  util2.assertNever = assertNever;
+  util2.arrayToEnum = (items) => {
+    const obj = {};
+    for (const item of items) {
+      obj[item] = item;
+    }
+    return obj;
+  };
+  util2.getValidEnumValues = (obj) => {
+    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
+    }
+    return util2.objectValues(filtered);
+  };
+  util2.objectValues = (obj) => {
+    return util2.objectKeys(obj).map(function(e) {
+      return obj[e];
+    });
+  };
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+    const keys = [];
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  };
+  util2.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
+    }
+    return void 0;
+  };
+  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+  function joinValues(array, separator = " | ") {
+    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+  }
+  util2.joinValues = joinValues;
+  util2.jsonStringifyReplacer = (_, value) => {
     if (typeof value === "bigint") {
       return value.toString();
     }
@@ -4982,6 +5275,106 @@ var z = /* @__PURE__ */ Object.freeze({
   quotelessJson,
   ZodError
 });
+const serviceVariantDescriptorSchema = z.object({
+  type: z.string(),
+  version: z.string(),
+  tags: z.record(z.string(), z.string()).optional(),
+  default: z.boolean().optional()
+}).strict();
+const servicesCatalogSchema = z.record(z.string(), serviceVariantDescriptorSchema);
+const operationServiceRefSchema = z.object({
+  ref: z.string()
+}).strict();
+const operationServiceInlineSchema = z.object({
+  version: z.string(),
+  tags: z.record(z.string(), z.string()).optional(),
+  // Capture but disallow to provide a clearer error
+  optional: z.boolean().optional()
+}).strict().superRefine((val, ctx) => {
+  if (val.optional !== void 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["optional"],
+      message: "optional is not allowed for service overrides"
+    });
+  }
+});
+const operationServicesSchema = z.record(
+  z.string(),
+  z.union([operationServiceRefSchema, operationServiceInlineSchema])
+);
+const componentsOnestoreServicesSchema = z.object({ onestore: z.object({ services: servicesCatalogSchema }).strict() }).strict();
+const operationOnestoreServicesSchema = z.object({ onestore: z.object({ services: operationServicesSchema }).strict() }).strict();
+function validateAndNormalizeCatalog(catalog) {
+  const parsed = servicesCatalogSchema.safeParse(catalog);
+  if (!parsed.success) {
+    throw new Error(parsed.error.message);
+  }
+  const defaultsByType = {};
+  for (const [alias, descriptor] of Object.entries(parsed.data)) {
+    if (descriptor.default) {
+      const prior = defaultsByType[descriptor.type];
+      if (prior !== void 0 && prior !== alias) {
+        throw new Error(
+          `Multiple defaults defined for service type '${descriptor.type}': '${prior}' and '${alias}'`
+        );
+      }
+      defaultsByType[descriptor.type] = alias;
+    }
+  }
+  return { catalog: parsed.data, defaultsByType };
+}
+function resolveOperationServices(services, catalog) {
+  const result = {};
+  for (const [canonicalName, entry] of Object.entries(services)) {
+    if ("ref" in entry) {
+      const alias = entry.ref;
+      const descriptor = catalog == null ? void 0 : catalog.catalog[alias];
+      if (!descriptor) {
+        throw new Error(`ref '${alias}' does not exist in the catalog`);
+      } else if (descriptor.default) {
+        throw new Error(`ref is not required for default service '${alias}'`);
+      } else if (descriptor.type !== canonicalName) {
+        throw new Error(
+          `Service '${alias}' uses non-canonical type '${descriptor.type}'. Expected canonical type '${canonicalName}'`
+        );
+      }
+      result[canonicalName] = {
+        type: descriptor.type,
+        version: descriptor.version,
+        tags: descriptor.tags
+      };
+    } else {
+      const inline = entry;
+      result[canonicalName] = {
+        type: canonicalName,
+        version: inline.version,
+        tags: inline.tags
+      };
+    }
+  }
+  return result;
+}
+function resolveDefaultServiceOverrides(catalog) {
+  const result = {};
+  if (catalog) {
+    for (const [alias, type] of Object.entries(catalog.defaultsByType)) {
+      const entry = catalog.catalog[type];
+      if (entry && !result[entry.type]) {
+        result[entry.type] = {
+          type: entry.type,
+          version: entry.version,
+          tags: entry.tags
+        };
+      } else {
+        throw new Error(
+          `Missing or multiple default service overrides for service ${alias}`
+        );
+      }
+    }
+  }
+  return result;
+}
 function formatZodError(err2) {
   const formattedIssues = err2.issues.map((iss) => {
     if (iss.code === "invalid_type") {
@@ -5146,6 +5539,15 @@ function buildExtensionScalar(graph) {
   const value = [DOUBLE_DATA_TYPE, INTEGER_DATA_TYPE, NUMBER_DATA_TYPE].includes(rawType) ? Number(rawValue) : rawType === BOOLEAN_DATA_TYPE ? rawValue === "true" : String(rawValue);
   return value;
 }
+const rootExtensionSchema = z.object({
+  onestore: z.object({
+    version: z.string().refine(stringIsVersion, () => {
+      return {
+        message: "Version must satisfy format major[.minor[.patch]]"
+      };
+    })
+  })
+});
 const cacheControl = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("max-age"),
@@ -5213,1512 +5615,1425 @@ const typeExtensions = z.object({
   // @todo: .strict();
   "cache-control": cacheControl
 }).strict();
-const annotationSchema = z.object({
-  onestore: typeExtensions.optional()
+const baseExtensionsSchema = z.object({
+  onestore: z.object({
+    defaults: z.object({
+      operations: z.object({
+        "cache-strategy": z.discriminatedUnion("type", [
+          z.object({ type: z.literal("none") }).strict(),
+          z.object({ type: z.literal("resource") }).strict(),
+          z.object({ type: z.literal("normalized") }).strict()
+        ])
+      }),
+      schemas: z.object({
+        "cache-control": cacheControl
+      })
+    }).partial().strict().optional(),
+    // Allow service catalog at root-level for reliability
+    services: servicesCatalogSchema.optional(),
+    namespace: z.string().optional(),
+    version: z.string()
+  }).strict()
 });
-class AMFBaseType {
-  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
-    var _a;
-    this.api = api;
-    this.shape = shape;
-    this.typeRegistry = typeRegistry;
-    this.factory = factory;
-    this.logger = logger;
-    this.fileParserLogger = fileParserLogger;
-    this.resolved = false;
-    this.parsedExtensions = { type: "unidentifiable" };
-    const { line = 0, column = 0 } = ((_a = this.shape.position) == null ? void 0 : _a.start) || {};
-    this.shapePosition = { line, column };
-  }
-  resolve() {
-    var _a;
-    if (!this.resolved) {
-      this.resolved = true;
-      const annotationResult = annotationSchema.safeParse(
-        extractExtensions(this.shape.customDomainProperties)
-      );
-      if (!annotationResult.success) {
-        const message = formatZodError(annotationResult.error);
-        this.fileParserLogger.error(
-          this.shape.position.start,
-          `Errors validating type:
-${message}`
+const cacheInvalidationEntrySchema = z.object({
+  ref: z.string(),
+  key: z.record(z.string(), z.string())
+});
+const cacheInvalidationSchema = z.object({
+  onestore: z.object({
+    invalidate: z.array(cacheInvalidationEntrySchema)
+  })
+});
+class OperationSchemaBuilder {
+  constructor(method, operationId, operationCacheStrategyType) {
+    this.method = method;
+    this.operationId = operationId;
+    this.operationCacheStrategyType = operationCacheStrategyType;
+  }
+  buildOperationSchema() {
+    const bindingSchema = z.object({
+      type: z.enum(BindingTypesEnum).default("wire"),
+      identifier: z.string().default("")
+    });
+    const configSchema = z.object({
+      "operation-type": z.enum(["query", "mutation", "graphql"]).default(this.method === "GET" ? "query" : "mutation"),
+      schema: z.enum(["flattened", "default"]).default("default"),
+      bindings: z.array(bindingSchema).default([]),
+      exposeRefresh: z.boolean().default(false),
+      "body-param": z.string().optional()
+    }).default({}).transform((config, ctx) => {
+      const { bindings, "operation-type": operationType } = config;
+      if (bindings.length === 0) {
+        if (!this.operationId) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `operationId is required for adapter name generation when no explicit bindings defined for operation. Add an operationId or expicit bindings annotation.`
+          });
+          return config;
+        }
+        if (operationType === "graphql") {
+          config.bindings = [{ type: "wire", identifier: this.operationId }];
+          return config;
+        } else {
+          const bindingType = operationType === "query" ? "wire" : "imperative";
+          config.bindings = [{ type: bindingType, identifier: this.operationId }];
+        }
+      } else if (bindings.length === 1) {
+        if (!bindings[0].identifier) {
+          if (!this.operationId) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `operationId is required for adapter name generation when one explicit binding is requested without an identifier. Add an operationId or a binding identifier.`
+            });
+            return config;
+          }
+          bindings[0].identifier = this.operationId;
+        }
+      }
+      return config;
+    }).refine(
+      (config) => {
+        const { bindings, "operation-type": operationType } = config;
+        if (operationType === "mutation") {
+          return !bindings.some(
+            (binding) => binding.type === "wire" || binding.type === "imperative-legacy"
+          );
+        }
+        return true;
+      },
+      {
+        message: 'Cannot use "wire" or "imperative-legacy" binding with operation-type "mutation"'
+      }
+    ).refine(
+      (config) => {
+        const { "operation-type": operationType, exposeRefresh } = config;
+        return !(exposeRefresh && operationType === "mutation");
+      },
+      {
+        message: 'Cannot exposeRefresh with operation-type "mutation"'
+      }
+    ).refine(
+      (config) => {
+        const { bindings, exposeRefresh } = config;
+        if (!exposeRefresh) {
+          return true;
+        }
+        return bindings.some(
+          (binding) => binding.type === "wire" || binding.type === "imperative"
         );
-        throw new Error();
+      },
+      {
+        message: 'Cannot use exposeRefresh without a "wire" or "imperative" binding'
       }
-      if ((_a = annotationResult.data.onestore) == null ? void 0 : _a.key) {
-        this.parsedExtensions = {
-          type: "identifiable",
-          ...annotationResult.data.onestore
-        };
+    ).refine(
+      (config) => {
+        const { bindings } = config;
+        if (bindings.length <= 1) {
+          return true;
+        }
+        return bindings.every((binding) => !!binding.identifier);
+      },
+      {
+        message: "Binding identifier is required if more than one binding is provided."
       }
-      this.logger.trace("Running this types resolution");
-      this.typeResolve();
-    } else {
-      this.logger.trace("Type was already resolved");
-    }
-  }
-  /*
-  Placeholder for type specific resolution
-  */
-  typeResolve() {
+    ).refine(
+      (config) => {
+        const { bindings } = config;
+        if (bindings.length <= 1) {
+          return true;
+        }
+        const identifiers = bindings.map((binding) => binding.identifier);
+        return new Set(identifiers).size === identifiers.length;
+      },
+      { message: "Binding identifier must be unique" }
+    ).refine(
+      (config) => {
+        const { bindings, "operation-type": operationType } = config;
+        if (operationType !== "graphql") {
+          return !bindings.some((binding) => binding.type === "mutation");
+        }
+        return true;
+      },
+      {
+        message: 'Cannot use "mutation" binding with non-graphql operations'
+      }
+    ).superRefine((config, ctx) => {
+      config.bindings.forEach((binding) => {
+        const tsSafeIdentifier = toTypeScriptSafeIdentifier(binding.identifier);
+        if (binding.identifier !== tsSafeIdentifier) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Invalid identifier "${binding.identifier}" for adapter binding. This may be derived from operationId. Use a valid TypeScript variable name, e.g. '${tsSafeIdentifier}'.`
+          });
+        }
+      });
+    });
+    return z.object({
+      onestore: z.object({
+        config: configSchema,
+        "cache-strategy": operationCacheStrategy(this.operationCacheStrategyType),
+        "error-strategy": z.discriminatedUnion("type", [
+          z.object({ type: z.literal("stringified") }).strict(),
+          z.object({ type: z.literal("fetchResponse") }).strict()
+        ]).default({ type: "stringified" }),
+        services: operationServicesSchema.optional()
+      }).strict().default({}).transform((extensions) => {
+        var _a;
+        if (((_a = extensions["cache-strategy"]) == null ? void 0 : _a.type) === "normalized" && extensions.config["operation-type"] === "mutation") {
+          if (extensions["cache-strategy"]["cache-control"] === void 0) {
+            extensions["cache-strategy"]["cache-control"] = {
+              type: "no-cache"
+            };
+          }
+        }
+        return extensions;
+      }).refine(
+        (extensions) => {
+          var _a;
+          if (((_a = extensions["cache-strategy"]) == null ? void 0 : _a.type) === "normalized") {
+            const cacheControl2 = extensions["cache-strategy"]["cache-control"];
+            if (extensions.config["operation-type"] === "mutation" && cacheControl2) {
+              return cacheControl2.type === "no-cache";
+            }
+          }
+          return true;
+        },
+        {
+          message: 'Cannot use "cache-control" values other than "no-cache" with operation-type "mutation"'
+        }
+      ).refine(
+        (extensions) => {
+          var _a;
+          if (((_a = extensions["cache-strategy"]) == null ? void 0 : _a.type) === "normalized") {
+            if (extensions.config["operation-type"] === "query") {
+              return extensions["cache-strategy"]["cache-control"] !== void 0;
+            }
+          }
+          return true;
+        },
+        {
+          message: 'Cannot use undefined "cache-control" with operation-type "query"'
+        }
+      ).refine(
+        (extensions) => {
+          var _a;
+          if (extensions.config["operation-type"] === "graphql") {
+            return ((_a = extensions["cache-strategy"]) == null ? void 0 : _a.type) === "normalized";
+          }
+          return true;
+        },
+        {
+          message: "GraphQL operations must use normalized cache strategy"
+        }
+      )
+    });
   }
-  get extensions() {
-    if (this.parsedExtensions.type === "identifiable") {
-      const CACHE_CONTROL = "cache-control";
-      const defaults = this.api.defaults.typeCacheControl;
+  buildHttpOperationSchema() {
+    return this.buildOperationSchema().transform((config, _ctx) => {
+      let bodyParam = config.onestore.config["body-param"] === void 0 ? "inputPayload" : config.onestore.config["body-param"];
       return {
-        ...this.parsedExtensions,
-        [CACHE_CONTROL]: {
-          ...defaults,
-          ...this.parsedExtensions[CACHE_CONTROL]
+        onestore: {
+          config: {
+            ...config.onestore.config,
+            "body-param": bodyParam
+          }
         }
       };
-    } else {
-      return this.parsedExtensions;
-    }
+    });
   }
-}
-class AMFAnyTypeImpl extends AMFBaseType {
-  constructor() {
-    super(...arguments);
-    this.type = "any";
+  buildAuraOperationSchema() {
+    return this.buildOperationSchema().and(
+      z.object({
+        onestore: z.object({
+          config: z.object({
+            aura: z.object({
+              method: z.string()
+            })
+          })
+        })
+      })
+    );
   }
-}
-class AMFObjectTypeImpl extends AMFBaseType {
-  constructor() {
-    super(...arguments);
-    this.type = "object";
-    this.properties = {};
-    this.resolved = false;
-    this.additionalProperties = { type: "any" };
+  buildAuraOperationWithBodySchema() {
+    return this.buildAuraOperationSchema().and(
+      z.object({
+        onestore: z.object({
+          config: z.object({
+            aura: z.object({
+              "body-param": z.string().optional()
+            })
+          })
+        })
+      })
+    ).transform((config, ctx) => {
+      let topLevelParam = config.onestore.config["body-param"];
+      let auraParam = config.onestore.config.aura["body-param"];
+      if (topLevelParam === void 0 && auraParam === void 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Missing body-param in both x-onestore.config and x-onestore.config.aura."
+        });
+        return z.NEVER;
+      }
+      if (topLevelParam !== void 0 && auraParam !== void 0) {
+        return config;
+      }
+      if (topLevelParam === void 0) {
+        topLevelParam = auraParam;
+      }
+      if (auraParam === void 0) {
+        auraParam = topLevelParam;
+      }
+      return {
+        onestore: {
+          config: {
+            ...config.onestore.config,
+            "body-param": topLevelParam,
+            aura: {
+              ...config.onestore.config.aura,
+              "body-param": auraParam
+            }
+          }
+        }
+      };
+    });
   }
-  typeResolve() {
-    var _a;
-    if (((_a = this.shape.values) == null ? void 0 : _a.length) > 0) {
+  buildGraphQLOperationSchema() {
+    return this.buildOperationSchema().and(
+      z.object({
+        onestore: z.object({
+          config: z.object({
+            graphql: z.object({
+              schema: z.string(),
+              "type-metadata": z.array(
+                z.object({
+                  typename: z.string(),
+                  "cache-control": cacheControl
+                })
+              ).default([])
+            })
+          })
+        })
+      })
+    );
+  }
+}
+class AmfBaseOperation {
+  constructor(amfOperation, amfTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
+    this.amfOperation = amfOperation;
+    this.amfTypeFactory = amfTypeFactory2;
+    this.typeRegistry = typeRegistry;
+    this.logger = logger;
+    this.fileParserLogger = fileParserLogger;
+    this.endpoint = endpoint;
+    this.server = server;
+    this.defaults = endpoint.api.defaults;
+    this.method = this.amfOperation.method.value().toUpperCase();
+    this.position = {
+      line: this.amfOperation.position.lineFrom.valueOf(),
+      column: this.amfOperation.position.columnFrom.valueOf()
+    };
+    const extensionsRaw = extractExtensions(this.amfOperation.customDomainProperties);
+    this.operationId = this.amfOperation.operationId.value() || this.amfOperation.name.value();
+    this.operationSchemaBuilder = new OperationSchemaBuilder(
+      this.method,
+      this.operationId,
+      this.defaults.operationCacheStrategy
+    );
+    const extensionsResult = this.operationSchemaBuilder.buildOperationSchema().default({}).safeParse(extensionsRaw);
+    if (!extensionsResult.success) {
+      const message = formatZodError(extensionsResult.error);
       this.fileParserLogger.error(
-        this.shapePosition,
-        `Type Error (${this.shape.name.value()}). Object type may not specify enum property.`
+        this.amfOperation.position.start,
+        `Error validating operation:
+${message}`
       );
-      throw new Error();
+      throw new Error(`Error validating operation:
+${message}`);
     }
-    this.logger.trace("Resolving properties");
-    this.resolveProperties();
-    this.logger.trace("Resolving additional properties");
-    this.resolveAdditionalProperties();
-  }
-  resolveProperties() {
-    for (const property of this.shape.properties) {
-      const propertyName = property.name.value();
-      const type = this.factory(
-        this.api,
-        property.range,
-        this.typeRegistry,
-        this.logger,
-        this.fileParserLogger,
-        true
+    const extensions = extensionsResult.data;
+    this.operationType = extensions.onestore.config["operation-type"];
+    this.configSchemaType = extensions.onestore.config.schema;
+    this.bindings = extensions.onestore.config.bindings;
+    this.exposeRefresh = extensions.onestore.config.exposeRefresh;
+    this.parsedCacheStrategy = extensions.onestore["cache-strategy"];
+    this.errorStrategy = extensions.onestore["error-strategy"];
+    this.basePath = this.endpoint.api.basePath;
+    if (extensions.onestore.services) {
+      this.serviceOverrides = resolveOperationServices(
+        extensions.onestore.services,
+        this.endpoint.api.serviceOverrides
       );
-      type.resolve();
-      const propertyType = {
-        type,
-        required: property.minCount.value() !== 0
-      };
-      this.properties[propertyName] = propertyType;
+    } else {
+      this.serviceOverrides = {};
     }
+    this.requests = this.amfOperation.requests.map((request) => {
+      return {
+        queryParameters: this.buildParams(request.queryParameters),
+        uriParameters: this.buildParams(request.uriParameters),
+        payloads: this.buildPayloads(request),
+        cookies: this.buildParams(request.cookieParameters),
+        headers: this.buildParams(request.headers)
+      };
+    });
+    this.responses = this.amfOperation.responses.map((response) => {
+      const extensionsRaw2 = extractExtensions(response.customDomainProperties);
+      if (extensionsRaw2.onestore !== void 0) {
+        const extensionsResult2 = cacheInvalidationSchema.safeParse(extensionsRaw2);
+        if (!extensionsResult2.success) {
+          const message = formatZodError(extensionsResult2.error);
+          this.fileParserLogger.error(
+            this.amfOperation.position.start,
+            `Error validating operation invalidation annotation:
+${message}`
+          );
+          throw new Error(
+            `Error validating operation invalidation annotation:
+${message}`
+          );
+        }
+        const extensions2 = extensionsResult2.data;
+        if (Object.keys(extensions2.onestore.invalidate).length > 0 && this.operationType === "query") {
+          this.fileParserLogger.error(
+            this.position,
+            `Cannot use an invalidate extension on a query type adapter`
+          );
+          throw new Error();
+        }
+        return {
+          statusCode: response.statusCode.value(),
+          headers: this.buildParams(response.headers),
+          payloads: this.buildPayloads(response),
+          invalidation: extensions2.onestore.invalidate
+        };
+      }
+      return {
+        statusCode: response.statusCode.value(),
+        headers: this.buildParams(response.headers),
+        payloads: this.buildPayloads(response)
+      };
+    });
   }
-  resolveAdditionalProperties() {
-    if (this.shape.closed.value()) {
-      this.additionalProperties = {
-        type: "not",
-        not: { type: "any" }
+  get cacheStrategy() {
+    return this.parsedCacheStrategy;
+  }
+  buildPayloads(r) {
+    return r.payloads.map((payload) => {
+      return {
+        mediaType: payload.mediaType.value(),
+        data: this.amfTypeFactory(
+          {},
+          payload.schema,
+          this.typeRegistry,
+          this.logger,
+          this.fileParserLogger,
+          true
+        )
       };
-    } else if (this.shape.additionalPropertiesSchema) {
-      this.additionalProperties = this.factory(
-        this.api,
-        this.shape.additionalPropertiesSchema,
-        this.typeRegistry,
-        this.logger,
-        this.fileParserLogger,
-        true
-      );
+    });
+  }
+  getDefaultValue(param) {
+    var _a, _b;
+    const defaultValue = (_a = param.schema) == null ? void 0 : _a.defaultValue;
+    if (defaultValue) {
+      return (_b = defaultValue.value) == null ? void 0 : _b.value();
     }
   }
+  buildParams(p) {
+    const params = {};
+    p.forEach((param) => {
+      params[`${param.name.value()}`] = {
+        required: param.required.value(),
+        type: this.amfTypeFactory(
+          {},
+          param.schema,
+          this.typeRegistry,
+          this.logger,
+          this.fileParserLogger,
+          true
+        ),
+        explode: param.explode.value(),
+        defaultValue: this.getDefaultValue(param)
+      };
+    });
+    return params;
+  }
 }
-class AMFNilTypeImpl extends AMFBaseType {
+class AmfHttpOperation extends AmfBaseOperation {
   constructor() {
     super(...arguments);
-    this.type = "nil";
+    this.type = "http";
   }
 }
-class AMFNotTypeImpl extends AMFBaseType {
-  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
-    super(api, shape, typeRegistry, factory, logger, fileParserLogger);
-    this.shape = shape;
-    this.typeRegistry = typeRegistry;
-    this.factory = factory;
-    this.logger = logger;
-    this.fileParserLogger = fileParserLogger;
-    this.type = "not";
-    const amfType = this.factory(
-      this.api,
-      this.shape.not,
-      this.typeRegistry,
-      this.logger,
-      this.fileParserLogger
-    );
-    amfType.resolve();
-    this.not = amfType;
-  }
-}
-class AMFAllOfTypeImpl extends AMFBaseType {
-  constructor() {
-    super(...arguments);
-    this.type = "allOf";
-    this.allOf = [];
-  }
-  typeResolve() {
-    this.logger.trace("Running resolution for inherited and composed shapes");
-    const allOfTypes = [...this.shape.inherits, ...this.shape.and].map(
-      (inheritedShape) => {
-        return this.factory(
-          this.api,
-          inheritedShape,
-          this.typeRegistry,
-          this.logger,
-          this.fileParserLogger,
-          true
-        );
-      }
-    );
-    const rootType = this.factory(
-      this.api,
-      this.shape,
-      this.typeRegistry,
-      this.logger,
-      this.fileParserLogger,
-      true,
-      /* @__PURE__ */ new Set([
-        "any",
-        "ref",
-        "array",
-        "boolean",
-        "date",
-        "number",
-        "datetime",
-        "datetime-only",
-        "double",
-        "integer",
-        "nil",
-        "not",
-        "number",
-        "object",
-        "string",
-        "time"
-      ]),
-      true
+class AmfHttpOperationWithRequestBody extends AmfBaseOperation {
+  constructor(amfOperation, amfTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
+    super(
+      amfOperation,
+      amfTypeFactory2,
+      typeRegistry,
+      logger,
+      fileParserLogger,
+      endpoint,
+      server
     );
-    this.allOf = [rootType, ...allOfTypes];
-    if (isOneOfShape(this.shape)) {
-      const OneOf = this.factory(
-        this.api,
-        this.shape,
-        this.typeRegistry,
-        this.logger,
-        this.fileParserLogger,
-        true,
-        /* @__PURE__ */ new Set(["oneOf"]),
-        true
-      );
-      this.allOf.push(OneOf);
+    this.type = "http";
+    const hasRequestBody = amfOperation.requests.some((request) => request.payloads.length > 0);
+    if (!hasRequestBody) {
+      throw new Error("Operation must have a request body defined");
     }
-    if (isEnumShape(this.shape)) {
-      const enumType2 = this.factory(
-        this.api,
-        this.shape,
-        this.typeRegistry,
-        this.logger,
-        this.fileParserLogger,
-        true,
-        /* @__PURE__ */ new Set(["enum"]),
-        true
+    this.method = amfOperation.method.value().toUpperCase();
+    const extensionsRaw = extractExtensions(amfOperation.customDomainProperties);
+    const extensionsResult = this.operationSchemaBuilder.buildHttpOperationSchema().default({}).safeParse(extensionsRaw);
+    if (!extensionsResult.success) {
+      const message = formatZodError(extensionsResult.error);
+      this.fileParserLogger.error(
+        this.amfOperation.position.start,
+        `Error validating aura operation:
+${message}`
       );
-      this.allOf.push(enumType2);
+      throw new Error();
     }
-    this.validateDiscriminators();
-  }
-  includes(t) {
-    return this.allOf.some((parent) => {
-      const canonicalizedParent = canonicalizeType(parent);
-      if (canonicalizedParent === t) {
-        return true;
-      }
-      return canonicalizedParent.type === "allOf" && canonicalizedParent.includes(t);
-    });
+    const extensions = extensionsResult.data;
+    if (!extensions.onestore.config["body-param"]) {
+      throw new Error("Missing body-param");
+    }
+    this.configBodyParam = extensions.onestore.config["body-param"];
   }
-  get discriminatedParent() {
-    var _a;
-    const discriminatedParents = [
-      ...bfs(
-        [this],
-        (type) => {
-          return isDiscriminatedObjectType(type);
-        },
-        (type) => {
-          return type.type === "allOf" ? type.allOf : type.type === "ref" ? [type.$ref] : [];
-        }
-      ).values()
-    ];
-    if (discriminatedParents.length === 0) {
-      return;
+}
+class AmfAuraOperation extends AmfBaseOperation {
+  constructor(amfOperation, amfTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
+    super(
+      amfOperation,
+      amfTypeFactory2,
+      typeRegistry,
+      logger,
+      fileParserLogger,
+      endpoint,
+      server
+    );
+    this.type = "aura";
+    const hasRequestBody = amfOperation.requests.some((request) => request.payloads.length > 0);
+    if (hasRequestBody) {
+      throw new Error("Operation must not have a request body defined");
     }
-    if (discriminatedParents.length > 1) {
-      const { line = 0, column = 0 } = ((_a = this.shape.position) == null ? void 0 : _a.start) || {};
+    this.method = amfOperation.method.value().toUpperCase();
+    const extensionsRaw = extractExtensions(amfOperation.customDomainProperties);
+    const extensionsResult = this.operationSchemaBuilder.buildAuraOperationSchema().safeParse(extensionsRaw);
+    if (!extensionsResult.success) {
+      const message = formatZodError(extensionsResult.error);
       this.fileParserLogger.error(
-        { line, column },
-        `Type ${this.typeRegistry.nameOf(
-          this
-        )} cannot inherit from multiple discriminated objects. Inherits from ${discriminatedParents.map(
-          (parent) => this.typeRegistry.nameOf(parent)
-        )}.`
+        this.amfOperation.position.start,
+        `Error validating aura operation:
+${message}`
       );
       throw new Error();
     }
-    return discriminatedParents[0];
-  }
-  validateDiscriminators() {
-    this.discriminatedParent;
-  }
-  get extensions() {
-    var _a, _b;
-    if (super.extensions.type === "identifiable") {
-      return super.extensions;
-    }
-    if (((_b = (_a = this.discriminatedParent) == null ? void 0 : _a.extensions) == null ? void 0 : _b.type) === "identifiable") {
-      return this.discriminatedParent.extensions;
-    }
-    return super.extensions;
+    const extensions = extensionsResult.data;
+    this.aura = { methodName: extensions.onestore.config.aura.method };
   }
 }
-class AMFEnumerableScalarType extends AMFBaseType {
-  typeResolve() {
-    var _a;
-    if (((_a = this.shape.values) == null ? void 0 : _a.length) > 0) {
-      this.values = getEnumValuesFromShape(this.shape);
+class AmfAuraOperationWithRequestBody extends AmfBaseOperation {
+  constructor(amfOperation, amfTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
+    super(
+      amfOperation,
+      amfTypeFactory2,
+      typeRegistry,
+      logger,
+      fileParserLogger,
+      endpoint,
+      server
+    );
+    this.type = "aura";
+    const hasRequestBody = amfOperation.requests.some((request) => request.payloads.length > 0);
+    if (!hasRequestBody) {
+      throw new Error("Operation must have a request body defined");
     }
-    if (this.parsedExtensions.type === "identifiable") {
+    this.method = amfOperation.method.value().toUpperCase();
+    const extensionsRaw = extractExtensions(amfOperation.customDomainProperties);
+    const extensionsResult = this.operationSchemaBuilder.buildAuraOperationWithBodySchema().safeParse(extensionsRaw);
+    if (!extensionsResult.success) {
+      const message = formatZodError(extensionsResult.error);
       this.fileParserLogger.error(
-        this.shape.position.start,
-        `${this.shape.name} is scalar and thus cannot be made identifiable by specifying a key`
+        this.amfOperation.position.start,
+        `Error validating aura operation:
+${message}`
       );
       throw new Error();
     }
+    const extensions = extensionsResult.data;
+    if (extensions.onestore.config["body-param"] === void 0) {
+      throw new Error("Missing body param");
+    }
+    if (extensions.onestore.config.aura["body-param"] === void 0) {
+      throw new Error("Missing aura body param");
+    }
+    this.configBodyParam = extensions.onestore.config["body-param"];
+    this.aura = {
+      methodName: extensions.onestore.config.aura.method,
+      bodyParam: extensions.onestore.config.aura["body-param"]
+    };
   }
 }
-class AMFBooleanTypeImpl extends AMFEnumerableScalarType {
-  constructor() {
-    super(...arguments);
-    this.type = "boolean";
-  }
+function AmfGraphQLOperationMixin(Base) {
+  return class AmfGraphQLOperation extends Base {
+    constructor(...args) {
+      super(...args);
+      this.operationType = "graphql";
+      this.graphqlConfig = this.setupGraphQLConfig();
+    }
+    setupGraphQLConfig() {
+      const extensionsRaw = extractExtensions(this.amfOperation.customDomainProperties);
+      const extensionsResult = this.operationSchemaBuilder.buildGraphQLOperationSchema().safeParse(extensionsRaw);
+      if (!extensionsResult.success) {
+        const message = formatZodError(extensionsResult.error);
+        this.fileParserLogger.error(
+          this.amfOperation.position.start,
+          `Error validating graphql operation:
+${message}`
+        );
+        throw new Error(message);
+      }
+      const extensions = extensionsResult.data;
+      const config = {
+        schemaFilePath: extensions.onestore.config.graphql.schema,
+        "type-metadata": extensions.onestore.config.graphql["type-metadata"]
+      };
+      return config;
+    }
+  };
 }
-class AMFDoubleTypeImpl extends AMFEnumerableScalarType {
-  constructor() {
-    super(...arguments);
-    this.type = "double";
-  }
-}
-class AMFIntegerTypeImpl extends AMFEnumerableScalarType {
-  constructor() {
-    super(...arguments);
-    this.type = "integer";
-  }
-}
-class AMFNumberTypeImpl extends AMFEnumerableScalarType {
-  constructor() {
-    super(...arguments);
-    this.type = "number";
-  }
-}
-class AMFStringTypeImpl extends AMFEnumerableScalarType {
-  constructor() {
-    super(...arguments);
-    this.type = "string";
-  }
-}
-class AMFDateTypeImpl extends AMFEnumerableScalarType {
-  constructor() {
-    super(...arguments);
-    this.type = "date";
-  }
-}
-const DATE = "date";
-const DATE_TIME = "date-time";
-class AMFDateTimeImpl extends AMFEnumerableScalarType {
-  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
-    super(api, shape, typeRegistry, factory, logger, fileParserLogger);
-    this.shape = shape;
-    this.type = "datetime";
-    const formatValue = shape.format.value();
-    this.format = formatValue === DATE ? DATE : DATE_TIME;
-  }
-}
-class AMFOneOfTypeImpl extends AMFBaseType {
-  constructor() {
-    super(...arguments);
-    this.type = "oneOf";
-    this.oneOf = [];
-  }
-  typeResolve() {
-    var _a;
-    let { anyOf = [], xone = [] } = this.shape;
-    this.oneOf = [...anyOf, ...xone].map((subTypeShape) => {
-      const subType = this.factory(
-        this.api,
-        subTypeShape,
-        this.typeRegistry,
-        this.logger,
-        this.fileParserLogger
+const endpointSchema = z.object({
+  onestore: z.discriminatedUnion("endpoint-type", [
+    z.object({
+      "endpoint-type": z.literal("http")
+    }).strict(),
+    z.object({
+      "endpoint-type": z.literal("aura"),
+      config: z.object({
+        aura: z.object({
+          controller: z.string()
+        })
+      }),
+      "network-preference": z.enum(["aura", "http"]).default("aura")
+    }).strict()
+  ]).optional()
+});
+const partialOperationSchema = z.object({
+  onestore: z.object({
+    config: z.object({
+      "operation-type": z.enum(["query", "mutation", "graphql"]).optional()
+    }).passthrough().optional()
+  }).passthrough().optional()
+});
+function createAmfAuraEndpoint(amfEndpoint, amfTypeFactory2, typeRegistry, logger, fileParserLogger, server, api, networkPreference) {
+  const endpoint = new AmfAuraEndpoint(
+    amfEndpoint,
+    [],
+    amfTypeFactory2,
+    typeRegistry,
+    logger,
+    fileParserLogger,
+    api,
+    networkPreference
+  );
+  const operations = amfEndpoint.operations.map((operation) => {
+    var _a, _b;
+    const extensionsRaw = extractExtensions(operation.customDomainProperties);
+    const operationConfigValidationResult = partialOperationSchema.safeParse(extensionsRaw);
+    if (!operationConfigValidationResult.success) {
+      const message = formatZodError(operationConfigValidationResult.error);
+      fileParserLogger.error(
+        operation.position.start,
+        `Errors validating operation:
+${message}`
       );
-      subType.resolve();
-      return subType;
-    });
-    if (((_a = this.shape.values) == null ? void 0 : _a.length) > 0) {
-      this.values = getEnumValuesFromShape(this.shape);
-    }
-    this.preserveIdentifiableExtensionsFromNullablePattern();
-  }
-  /**
-   * When AMF encounters 'nullable: true' on an object with identifiable extensions,
-   * it converts it to a oneOf with [object, null]. This method detects this pattern
-   * and preserves the identifiable extensions from the object member on the union.
-   */
-  preserveIdentifiableExtensionsFromNullablePattern() {
-    var _a;
-    if (this.oneOf.length !== 2) {
-      return;
-    }
-    const nullMember = this.oneOf.find((member) => member.type === "nil");
-    const objectMember = this.oneOf.find((member) => member.type === "object");
-    if (!nullMember || !objectMember) {
-      return;
-    }
-    if (((_a = objectMember.extensions) == null ? void 0 : _a.type) === "identifiable") {
-      this.parsedExtensions = { ...objectMember.extensions };
-    }
-  }
-}
-class AMFEnumTypeImpl extends AMFBaseType {
-  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
-    super(api, shape, typeRegistry, factory, logger, fileParserLogger);
-    this.shape = shape;
-    this.typeRegistry = typeRegistry;
-    this.factory = factory;
-    this.logger = logger;
-    this.fileParserLogger = fileParserLogger;
-    this.type = "enum";
-    this.values = [];
-    this.values = getEnumValuesFromShape(shape);
-  }
-}
-class AMFRefTypeImpl extends AMFBaseType {
-  constructor() {
-    super(...arguments);
-    this.type = "ref";
-    this.$ref = {
-      type: "not",
-      not: { type: "any" }
-    };
-    this.resolved = false;
-  }
-  typeResolve() {
-    this.logger.trace(`Resolving $ref at ${this.shape.id.split("#")[1]}`);
-    if (this.shape.isLink && this.shape.linkTarget) {
-      const inheritedType = this.typeRegistry.get(this.shape.linkLabel.toString());
-      if (inheritedType) {
-        this.logger.trace(`Found ${inheritedType.shape.name} for $ref`);
-        inheritedType.resolve();
-        this.$ref = inheritedType;
-      } else {
-        const errorMessage = `Failed to resolve $ref: ${this.shape.linkLabel.toString()} from ${this.shape.id}`;
-        this.fileParserLogger.error(this.shapePosition, errorMessage);
-        throw new Error(errorMessage);
-      }
+      throw new Error();
     }
-  }
+    const hasRequestBody = operation.requests.some((request) => request.payloads.length > 0);
+    const isGraphQLOperation = ((_b = (_a = operationConfigValidationResult.data.onestore) == null ? void 0 : _a.config) == null ? void 0 : _b["operation-type"]) === "graphql";
+    let baseClass = isGraphQLOperation ? AmfGraphQLOperationMixin(
+      hasRequestBody ? AmfAuraOperationWithRequestBody : AmfAuraOperation
+    ) : hasRequestBody ? AmfAuraOperationWithRequestBody : AmfAuraOperation;
+    return new baseClass(
+      operation,
+      amfTypeFactory2,
+      typeRegistry,
+      logger,
+      fileParserLogger,
+      endpoint,
+      server
+    );
+  });
+  endpoint.operations = operations;
+  return endpoint;
 }
-class AMFDiscriminatedObjectTypeImpl extends AMFBaseType {
-  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
-    super(api, shape, typeRegistry, factory, logger, fileParserLogger);
-    this.shape = shape;
-    this.typeRegistry = typeRegistry;
-    this.factory = factory;
-    this.logger = logger;
-    this.fileParserLogger = fileParserLogger;
-    this.type = "discriminatedObject";
-    this._mapping = void 0;
-    if (this.shape.discriminator.isNullOrEmpty) {
-      this.fileParserLogger.error(
-        this.shapePosition,
-        "Supplied shape does not provide a discriminator"
-      );
-      throw new Error();
+function createAmfHttpEndpoint(amfEndpoint, amfTypeFactory2, typeRegistry, logger, fileParserLogger, server, api) {
+  const endpoint = new AmfHttpEndPoint(
+    amfEndpoint,
+    [],
+    amfTypeFactory2,
+    typeRegistry,
+    logger,
+    fileParserLogger,
+    api
+  );
+  const operations = amfEndpoint.operations.map((operation) => {
+    var _a, _b;
+    const operationConfigValidationResult = partialOperationSchema.safeParse(
+      extractExtensions(operation.customDomainProperties)
+    );
+    if (!operationConfigValidationResult.success) {
+      const message = formatZodError(operationConfigValidationResult.error);
+      const errorMessage = `Error validating operation:
+${message}`;
+      fileParserLogger.error(operation.position.start, errorMessage);
+      throw new Error(errorMessage);
     }
-    this.discriminator = this.shape.discriminator.value();
-    this.baseType = factory(
-      api,
-      shape,
+    const hasRequestBody = operation.requests.some((request) => request.payloads.length > 0);
+    const isGraphQLOperation = ((_b = (_a = operationConfigValidationResult.data.onestore) == null ? void 0 : _a.config) == null ? void 0 : _b["operation-type"]) === "graphql";
+    let baseClass = isGraphQLOperation ? AmfGraphQLOperationMixin(
+      hasRequestBody ? AmfHttpOperationWithRequestBody : AmfHttpOperation
+    ) : hasRequestBody ? AmfHttpOperationWithRequestBody : AmfHttpOperation;
+    return new baseClass(
+      operation,
+      amfTypeFactory2,
       typeRegistry,
       logger,
       fileParserLogger,
-      false,
-      /* @__PURE__ */ new Set(["object"])
+      endpoint,
+      server
     );
+  });
+  endpoint.operations = operations;
+  return endpoint;
+}
+function amfEndpointFactory(amfEndpoint, amfTypeFactory2, typeRegistry, logger, fileParserLogger, server, api) {
+  const endpointConfigValidationResult = endpointSchema.safeParse(
+    extractExtensions(amfEndpoint.customDomainProperties)
+  );
+  if (!endpointConfigValidationResult.success) {
+    const message = formatZodError(endpointConfigValidationResult.error);
+    const errorMessage = `Error validating endpoint:
+${message}`;
+    fileParserLogger.error(amfEndpoint.position.start, errorMessage);
+    throw new Error(errorMessage);
   }
-  typeResolve() {
-    this.baseType.resolve();
-    if (this.typeRegistry.nameOf(this) === void 0) {
-      this.fileParserLogger.error(
-        this.shapePosition,
-        "Cannot use discriminator on inline types."
-      );
-      throw new Error();
-    }
-  }
-  get mapping() {
-    if (this._mapping === void 0) {
-      this._mapping = {};
-      this.resolveDiscriminator();
-    }
-    return this._mapping;
-  }
-  resolveDiscriminator() {
-    this.buildExplicitMapping();
-    this.buildImplicitMapping();
-  }
-  /**
-   * Adds implicit discriminator values (i.e., type names) as mappings to types
-   *
-   * @private
-   */
-  buildImplicitMapping() {
-    const oneOfNames = this.shape.xone.reduce((result, shape) => {
-      if (shape.isLink) {
-        result.push(shape.linkLabel.value());
-      }
-      return result;
-    }, []);
-    this.typeRegistry.forEach((type, name) => {
-      type.resolve();
-      if ((type.type === "allOf" && type.includes(this) || oneOfNames.includes(name)) && !Object.values(this._mapping).includes(type)) {
-        this._mapping[name] = type;
-      }
-    });
-  }
-  /**
-   * Adds explicit discriminator values as mappings to types
-   *
-   * @private
-   */
-  buildExplicitMapping() {
-    this.shape.discriminatorMapping.forEach((el) => {
-      const value = el.templateVariable.value();
-      const linkExpressionSplit = el.linkExpression.value().split("/");
-      const typeName = linkExpressionSplit[linkExpressionSplit.length - 1];
-      const type = this.typeRegistry.get(typeName);
-      if (type === void 0) {
-        this.fileParserLogger.error(this.shapePosition, `Cannot find type ${typeName}`);
-        throw new Error();
-      }
-      this._mapping[value] = type;
-    });
-  }
-}
-function amfTypeFactory(api, shape, typeRegistry, logger, fileParserLogger, resolve = false, allowedTypes = void 0, skipRegistry = false) {
-  var _a;
-  if (!skipRegistry) {
-    for (const [_, type] of typeRegistry.entries()) {
-      if (shape.id === type.shape.id) {
-        return type;
-      }
-    }
-  }
-  const { line = 0, column = 0 } = ((_a = shape.position) == null ? void 0 : _a.start) || {};
-  let ctor;
-  if (isAnyOfShape(shape)) {
-    fileParserLogger.error(
-      { line, column },
-      `anyOf is not suppoort, found in type ${shape.name.value()}`
-    );
-    throw new Error();
-  }
-  if (isRefShape(shape)) {
-    ctor = AMFRefTypeImpl;
-  } else if ((!allowedTypes || allowedTypes.has("allOf")) && isAllOfShape(shape)) {
-    ctor = AMFAllOfTypeImpl;
-  } else if ((!allowedTypes || allowedTypes.has("oneOf")) && isOneOfShape(shape)) {
-    ctor = AMFOneOfTypeImpl;
-  } else if ((!allowedTypes || allowedTypes.has("enum")) && isEnumShape(shape)) {
-    ctor = AMFEnumTypeImpl;
-  } else if ((!allowedTypes || allowedTypes.has("nil")) && isNilShape(shape)) {
-    ctor = AMFNilTypeImpl;
-  } else if (isScalarShape(shape) && shape.dataType.value() in DATATYPE_TO_SCALAR_TYPE && (!allowedTypes || allowedTypes.has(DATATYPE_TO_SCALAR_TYPE[shape.dataType.value()]))) {
-    const scalarType = DATATYPE_TO_SCALAR_TYPE[shape.dataType.value()];
-    switch (scalarType) {
-      case "string":
-        ctor = AMFStringTypeImpl;
-        break;
-      case "number":
-        ctor = AMFNumberTypeImpl;
-        break;
-      case "boolean":
-        ctor = AMFBooleanTypeImpl;
-        break;
-      case "double":
-        ctor = AMFDoubleTypeImpl;
-        break;
-      case "integer":
-        ctor = AMFIntegerTypeImpl;
-        break;
-      case "date":
-        ctor = AMFDateTypeImpl;
-        break;
-      case "datetime":
-        ctor = AMFDateTimeImpl;
-        break;
-      default:
-        fileParserLogger.error(
-          { line, column },
-          `type of shape ${shape.name.value()} not recognized`
-        );
-        throw new Error();
-    }
-  } else if ((!allowedTypes || allowedTypes.has("discriminatedObject")) && isNodeShape(shape) && !shape.discriminator.isNullOrEmpty) {
-    ctor = AMFDiscriminatedObjectTypeImpl;
-  } else if ((!allowedTypes || allowedTypes.has("object")) && isNodeShape(shape)) {
-    ctor = AMFObjectTypeImpl;
-  } else if ((!allowedTypes || allowedTypes.has("array")) && isArrayShape(shape)) {
-    ctor = AMFArrayTypeImpl;
-  } else if ((!allowedTypes || allowedTypes.has("not")) && isNotShape(shape)) {
-    ctor = AMFNotTypeImpl;
-  } else if ((!allowedTypes || allowedTypes.has("any")) && isAnyShape(shape)) {
-    ctor = AMFAnyTypeImpl;
-  } else {
-    fileParserLogger.error(
-      { line, column },
-      `type of shape ${shape.name.value()} not recognized`
-    );
-    throw new Error();
-  }
-  const result = new ctor(api, shape, typeRegistry, amfTypeFactory, logger, fileParserLogger);
-  if (resolve) {
-    result.resolve();
-  }
-  return result;
-}
-class AMFArrayTypeImpl extends AMFBaseType {
-  constructor() {
-    super(...arguments);
-    this.type = "array";
-    this.items = { type: "any" };
+  const config = endpointConfigValidationResult.data;
+  if (config.onestore === void 0) {
+    return void 0;
   }
-  typeResolve() {
-    if (this.shape.items) {
-      const items = amfTypeFactory(
-        this.api,
-        this.shape.items,
-        this.typeRegistry,
-        this.logger,
-        this.fileParserLogger
-      );
-      items.resolve();
-      this.items = items;
-    }
+  const endpoint = config.onestore["endpoint-type"] === "aura" ? createAmfAuraEndpoint(
+    amfEndpoint,
+    amfTypeFactory2,
+    typeRegistry,
+    logger,
+    fileParserLogger,
+    server,
+    api,
+    config.onestore["network-preference"]
+  ) : createAmfHttpEndpoint(
+    amfEndpoint,
+    amfTypeFactory2,
+    typeRegistry,
+    logger,
+    fileParserLogger,
+    server,
+    api
+  );
+  if (!validateUniqueBindingIdentfiers(endpoint.operations)) {
+    const errorMessage = `All operations must have unique bindings`;
+    fileParserLogger.error(amfEndpoint.position.start, errorMessage);
+    throw new Error(errorMessage);
   }
+  return endpoint;
 }
-const serviceVariantDescriptorSchema = z.object({
-  type: z.string(),
-  version: z.string(),
-  tags: z.record(z.string(), z.string()).optional(),
-  default: z.boolean().optional()
-}).strict();
-const servicesCatalogSchema = z.record(z.string(), serviceVariantDescriptorSchema);
-const operationServiceRefSchema = z.object({
-  ref: z.string()
-}).strict();
-const operationServiceInlineSchema = z.object({
-  version: z.string(),
-  tags: z.record(z.string(), z.string()).optional(),
-  // Capture but disallow to provide a clearer error
-  optional: z.boolean().optional()
-}).strict().superRefine((val, ctx) => {
-  if (val.optional !== void 0) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["optional"],
-      message: "optional is not allowed for service overrides"
+class AmfBaseEndpoint {
+  constructor(amfEndpoint, operations, amfTypeFactory2, typeRegistry, logger, fileParserLogger, api) {
+    this.amfEndpoint = amfEndpoint;
+    this.operations = operations;
+    this.logger = logger;
+    this.fileParserLogger = fileParserLogger;
+    this.api = api;
+    this.path = this.amfEndpoint.path.value();
+    this.uriParameters = {};
+    this.amfEndpoint.parameters.forEach((param) => {
+      this.uriParameters[`${param.name}`] = {
+        required: param.required.value(),
+        type: amfTypeFactory2(
+          this.api,
+          param.schema,
+          typeRegistry,
+          logger,
+          fileParserLogger,
+          true
+        ),
+        explode: param.explode.value()
+      };
     });
   }
-});
-const operationServicesSchema = z.record(
-  z.string(),
-  z.union([operationServiceRefSchema, operationServiceInlineSchema])
-);
-const componentsOnestoreServicesSchema = z.object({ onestore: z.object({ services: servicesCatalogSchema }).strict() }).strict();
-const operationOnestoreServicesSchema = z.object({ onestore: z.object({ services: operationServicesSchema }).strict() }).strict();
-function validateAndNormalizeCatalog(catalog) {
-  const parsed = servicesCatalogSchema.safeParse(catalog);
-  if (!parsed.success) {
-    throw new Error(parsed.error.message);
-  }
-  const defaultsByType = {};
-  for (const [alias, descriptor] of Object.entries(parsed.data)) {
-    if (descriptor.default) {
-      const prior = defaultsByType[descriptor.type];
-      if (prior !== void 0 && prior !== alias) {
-        throw new Error(
-          `Multiple defaults defined for service type '${descriptor.type}': '${prior}' and '${alias}'`
-        );
-      }
-      defaultsByType[descriptor.type] = alias;
-    }
-  }
-  return { catalog: parsed.data, defaultsByType };
-}
-function resolveOperationServices(services, catalog) {
-  const result = {};
-  for (const [canonicalName, entry] of Object.entries(services)) {
-    if ("ref" in entry) {
-      const alias = entry.ref;
-      const descriptor = catalog == null ? void 0 : catalog.catalog[alias];
-      if (!descriptor) {
-        throw new Error(`ref '${alias}' does not exist in the catalog`);
-      } else if (descriptor.default) {
-        throw new Error(`ref is not required for default service '${alias}'`);
-      } else if (descriptor.type !== canonicalName) {
-        throw new Error(
-          `Service '${alias}' uses non-canonical type '${descriptor.type}'. Expected canonical type '${canonicalName}'`
-        );
-      }
-      result[canonicalName] = {
-        type: descriptor.type,
-        version: descriptor.version,
-        tags: descriptor.tags
-      };
-    } else {
-      const inline = entry;
-      result[canonicalName] = {
-        type: canonicalName,
-        version: inline.version,
-        tags: inline.tags
-      };
-    }
-  }
-  return result;
-}
-function resolveDefaultServiceOverrides(catalog) {
-  const result = {};
-  if (catalog) {
-    for (const [alias, type] of Object.entries(catalog.defaultsByType)) {
-      const entry = catalog.catalog[type];
-      if (entry && !result[entry.type]) {
-        result[entry.type] = {
-          type: entry.type,
-          version: entry.version,
-          tags: entry.tags
-        };
-      } else {
-        throw new Error(
-          `Missing or multiple default service overrides for service ${alias}`
-        );
-      }
-    }
-  }
-  return result;
-}
-const cacheInvalidationEntrySchema = z.object({
-  ref: z.string(),
-  key: z.record(z.string(), z.string())
-});
-const cacheInvalidationSchema = z.object({
-  onestore: z.object({
-    invalidate: z.array(cacheInvalidationEntrySchema)
-  })
-});
-class OperationSchemaBuilder {
-  constructor(method, operationId, operationCacheStrategyType) {
-    this.method = method;
-    this.operationId = operationId;
-    this.operationCacheStrategyType = operationCacheStrategyType;
-  }
-  buildOperationSchema() {
-    const bindingSchema = z.object({
-      type: z.enum(BindingTypesEnum).default("wire"),
-      identifier: z.string().default("")
-    });
-    const configSchema = z.object({
-      "operation-type": z.enum(["query", "mutation", "graphql"]).default(this.method === "GET" ? "query" : "mutation"),
-      schema: z.enum(["flattened", "default"]).default("default"),
-      bindings: z.array(bindingSchema).default([]),
-      exposeRefresh: z.boolean().default(false),
-      "body-param": z.string().optional()
-    }).default({}).transform((config, ctx) => {
-      const { bindings, "operation-type": operationType } = config;
-      if (bindings.length === 0) {
-        if (!this.operationId) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `operationId is required for adapter name generation when no explicit bindings defined for operation. Add an operationId or expicit bindings annotation.`
-          });
-          return config;
-        }
-        if (operationType === "graphql") {
-          config.bindings = [{ type: "wire", identifier: this.operationId }];
-          return config;
-        } else {
-          const bindingType = operationType === "query" ? "wire" : "imperative";
-          config.bindings = [{ type: bindingType, identifier: this.operationId }];
-        }
-      } else if (bindings.length === 1) {
-        if (!bindings[0].identifier) {
-          if (!this.operationId) {
-            ctx.addIssue({
-              code: z.ZodIssueCode.custom,
-              message: `operationId is required for adapter name generation when one explicit binding is requested without an identifier. Add an operationId or a binding identifier.`
-            });
-            return config;
-          }
-          bindings[0].identifier = this.operationId;
-        }
-      }
-      return config;
-    }).refine(
-      (config) => {
-        const { bindings, "operation-type": operationType } = config;
-        if (operationType === "mutation") {
-          return !bindings.some(
-            (binding) => binding.type === "wire" || binding.type === "imperative-legacy"
-          );
-        }
-        return true;
-      },
-      {
-        message: 'Cannot use "wire" or "imperative-legacy" binding with operation-type "mutation"'
-      }
-    ).refine(
-      (config) => {
-        const { "operation-type": operationType, exposeRefresh } = config;
-        return !(exposeRefresh && operationType === "mutation");
-      },
-      {
-        message: 'Cannot exposeRefresh with operation-type "mutation"'
-      }
-    ).refine(
-      (config) => {
-        const { bindings, exposeRefresh } = config;
-        if (exposeRefresh) {
-          return !bindings.some((binding) => binding.type === "imperative-legacy");
-        }
-        return true;
-      },
-      {
-        message: 'Cannot exposeRefresh with "imperative-legacy" binding'
-      }
-    ).refine(
-      (config) => {
-        const { bindings } = config;
-        if (bindings.length <= 1) {
-          return true;
-        }
-        return bindings.every((binding) => !!binding.identifier);
-      },
-      {
-        message: "Binding identifier is required if more than one binding is provided."
-      }
-    ).refine(
-      (config) => {
-        const { bindings } = config;
-        if (bindings.length <= 1) {
-          return true;
-        }
-        const identifiers = bindings.map((binding) => binding.identifier);
-        return new Set(identifiers).size === identifiers.length;
-      },
-      { message: "Binding identifier must be unique" }
-    ).refine(
-      (config) => {
-        const { bindings, "operation-type": operationType } = config;
-        if (operationType !== "graphql") {
-          return !bindings.some((binding) => binding.type === "mutation");
-        }
-        return true;
-      },
-      {
-        message: 'Cannot use "mutation" binding with non-graphql operations'
-      }
-    ).superRefine((config, ctx) => {
-      config.bindings.forEach((binding) => {
-        const tsSafeIdentifier = toTypeScriptSafeIdentifier(binding.identifier);
-        if (binding.identifier !== tsSafeIdentifier) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Invalid identifier "${binding.identifier}" for adapter binding. This may be derived from operationId. Use a valid TypeScript variable name, e.g. '${tsSafeIdentifier}'.`
-          });
-        }
-      });
-    });
-    return z.object({
-      onestore: z.object({
-        config: configSchema,
-        "cache-strategy": operationCacheStrategy(this.operationCacheStrategyType),
-        "error-strategy": z.discriminatedUnion("type", [
-          z.object({ type: z.literal("stringified") }).strict(),
-          z.object({ type: z.literal("fetchResponse") }).strict()
-        ]).default({ type: "stringified" }),
-        services: operationServicesSchema.optional()
-      }).strict().default({}).transform((extensions) => {
-        var _a;
-        if (((_a = extensions["cache-strategy"]) == null ? void 0 : _a.type) === "normalized" && extensions.config["operation-type"] === "mutation") {
-          if (extensions["cache-strategy"]["cache-control"] === void 0) {
-            extensions["cache-strategy"]["cache-control"] = {
-              type: "no-cache"
-            };
-          }
-        }
-        return extensions;
-      }).refine(
-        (extensions) => {
-          var _a;
-          if (((_a = extensions["cache-strategy"]) == null ? void 0 : _a.type) === "normalized") {
-            const cacheControl2 = extensions["cache-strategy"]["cache-control"];
-            if (extensions.config["operation-type"] === "mutation" && cacheControl2) {
-              return cacheControl2.type === "no-cache";
-            }
-          }
-          return true;
-        },
-        {
-          message: 'Cannot use "cache-control" values other than "no-cache" with operation-type "mutation"'
-        }
-      ).refine(
-        (extensions) => {
-          var _a;
-          if (((_a = extensions["cache-strategy"]) == null ? void 0 : _a.type) === "normalized") {
-            if (extensions.config["operation-type"] === "query") {
-              return extensions["cache-strategy"]["cache-control"] !== void 0;
-            }
-          }
-          return true;
-        },
-        {
-          message: 'Cannot use undefined "cache-control" with operation-type "query"'
-        }
-      ).refine(
-        (extensions) => {
-          var _a;
-          if (extensions.config["operation-type"] === "graphql") {
-            return ((_a = extensions["cache-strategy"]) == null ? void 0 : _a.type) === "normalized";
-          }
-          return true;
-        },
-        {
-          message: "GraphQL operations must use normalized cache strategy"
-        }
-      )
-    });
-  }
-  buildHttpOperationSchema() {
-    return this.buildOperationSchema().transform((config, _ctx) => {
-      let bodyParam = config.onestore.config["body-param"] === void 0 ? "inputPayload" : config.onestore.config["body-param"];
-      return {
-        onestore: {
-          config: {
-            ...config.onestore.config,
-            "body-param": bodyParam
-          }
-        }
-      };
-    });
-  }
-  buildAuraOperationSchema() {
-    return this.buildOperationSchema().and(
-      z.object({
-        onestore: z.object({
-          config: z.object({
-            aura: z.object({
-              method: z.string()
-            })
-          })
-        })
-      })
-    );
-  }
-  buildAuraOperationWithBodySchema() {
-    return this.buildAuraOperationSchema().and(
-      z.object({
-        onestore: z.object({
-          config: z.object({
-            aura: z.object({
-              "body-param": z.string().optional()
-            })
-          })
-        })
-      })
-    ).transform((config, ctx) => {
-      let topLevelParam = config.onestore.config["body-param"];
-      let auraParam = config.onestore.config.aura["body-param"];
-      if (topLevelParam === void 0 && auraParam === void 0) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: "Missing body-param in both x-onestore.config and x-onestore.config.aura."
-        });
-        return z.NEVER;
-      }
-      if (topLevelParam !== void 0 && auraParam !== void 0) {
-        return config;
-      }
-      if (topLevelParam === void 0) {
-        topLevelParam = auraParam;
-      }
-      if (auraParam === void 0) {
-        auraParam = topLevelParam;
-      }
-      return {
-        onestore: {
-          config: {
-            ...config.onestore.config,
-            "body-param": topLevelParam,
-            aura: {
-              ...config.onestore.config.aura,
-              "body-param": auraParam
-            }
-          }
-        }
-      };
-    });
+}
+class AmfHttpEndPoint extends AmfBaseEndpoint {
+  constructor() {
+    super(...arguments);
+    this.type = "http";
   }
-  buildGraphQLOperationSchema() {
-    return this.buildOperationSchema().and(
-      z.object({
-        onestore: z.object({
-          config: z.object({
-            graphql: z.object({
-              schema: z.string(),
-              "type-metadata": z.array(
-                z.object({
-                  typename: z.string(),
-                  "cache-control": cacheControl
-                })
-              ).default([])
-            })
-          })
-        })
-      })
+}
+class AmfAuraEndpoint extends AmfBaseEndpoint {
+  constructor(amfEndPoint, operations, amfTypeFactory2, typeRegistry, logger, fileParserLogger, api, networkPreference) {
+    super(amfEndPoint, operations, amfTypeFactory2, typeRegistry, logger, fileParserLogger, api);
+    this.logger = logger;
+    this.fileParserLogger = fileParserLogger;
+    this.api = api;
+    this.networkPreference = networkPreference;
+    this.type = "aura";
+    this.auraController = this.buildAuraController();
+  }
+  buildAuraController() {
+    const configResult = endpointSchema.safeParse(
+      extractExtensions(this.amfEndpoint.customDomainProperties)
     );
+    if (!configResult.success) {
+      const message = formatZodError(configResult.error);
+      const errorMessage = `Error validating aura endpoint:
+${message}`;
+      this.fileParserLogger.error(this.amfEndpoint.position.start, errorMessage);
+      throw new Error(errorMessage);
+    }
+    const config = configResult.data;
+    if (!config.onestore || config.onestore["endpoint-type"] !== "aura") {
+      throw new Error("invalid config");
+    }
+    const name = config.onestore.config.aura.controller;
+    if (name === void 0) {
+      throw new Error("Aura controller name must be defined for an Aura endpoint.");
+    }
+    return { name };
   }
 }
-class AmfBaseOperation {
-  constructor(amfOperation, amfTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
-    this.amfOperation = amfOperation;
-    this.amfTypeFactory = amfTypeFactory2;
+const annotationSchema = z.object({
+  onestore: typeExtensions.optional()
+});
+class AMFBaseType {
+  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
+    var _a;
+    this.api = api;
+    this.shape = shape;
     this.typeRegistry = typeRegistry;
+    this.factory = factory;
     this.logger = logger;
     this.fileParserLogger = fileParserLogger;
-    this.endpoint = endpoint;
-    this.server = server;
-    this.defaults = endpoint.api.defaults;
-    this.method = this.amfOperation.method.value().toUpperCase();
-    this.position = {
-      line: this.amfOperation.position.lineFrom.valueOf(),
-      column: this.amfOperation.position.columnFrom.valueOf()
-    };
-    const extensionsRaw = extractExtensions(this.amfOperation.customDomainProperties);
-    this.operationId = this.amfOperation.operationId.value() || this.amfOperation.name.value();
-    this.operationSchemaBuilder = new OperationSchemaBuilder(
-      this.method,
-      this.operationId,
-      this.defaults.operationCacheStrategy
-    );
-    const extensionsResult = this.operationSchemaBuilder.buildOperationSchema().default({}).safeParse(extensionsRaw);
-    if (!extensionsResult.success) {
-      const message = formatZodError(extensionsResult.error);
-      this.fileParserLogger.error(
-        this.amfOperation.position.start,
-        `Error validating operation:
-${message}`
-      );
-      throw new Error(`Error validating operation:
-${message}`);
-    }
-    const extensions = extensionsResult.data;
-    this.operationType = extensions.onestore.config["operation-type"];
-    this.configSchemaType = extensions.onestore.config.schema;
-    this.bindings = extensions.onestore.config.bindings;
-    this.exposeRefresh = extensions.onestore.config.exposeRefresh;
-    this.parsedCacheStrategy = extensions.onestore["cache-strategy"];
-    this.errorStrategy = extensions.onestore["error-strategy"];
-    this.basePath = this.endpoint.api.basePath;
-    if (extensions.onestore.services) {
-      this.serviceOverrides = resolveOperationServices(
-        extensions.onestore.services,
-        this.endpoint.api.serviceOverrides
+    this.resolved = false;
+    this.parsedExtensions = { type: "unidentifiable" };
+    const { line = 0, column = 0 } = ((_a = this.shape.position) == null ? void 0 : _a.start) || {};
+    this.shapePosition = { line, column };
+  }
+  resolve() {
+    var _a;
+    if (!this.resolved) {
+      this.resolved = true;
+      const annotationResult = annotationSchema.safeParse(
+        extractExtensions(this.shape.customDomainProperties)
       );
-    } else {
-      this.serviceOverrides = {};
-    }
-    this.requests = this.amfOperation.requests.map((request) => {
-      return {
-        queryParameters: this.buildParams(request.queryParameters),
-        uriParameters: this.buildParams(request.uriParameters),
-        payloads: this.buildPayloads(request),
-        cookies: this.buildParams(request.cookieParameters),
-        headers: this.buildParams(request.headers)
-      };
-    });
-    this.responses = this.amfOperation.responses.map((response) => {
-      const extensionsRaw2 = extractExtensions(response.customDomainProperties);
-      if (extensionsRaw2.onestore !== void 0) {
-        const extensionsResult2 = cacheInvalidationSchema.safeParse(extensionsRaw2);
-        if (!extensionsResult2.success) {
-          const message = formatZodError(extensionsResult2.error);
-          this.fileParserLogger.error(
-            this.amfOperation.position.start,
-            `Error validating operation invalidation annotation:
-${message}`
-          );
-          throw new Error(
-            `Error validating operation invalidation annotation:
+      if (!annotationResult.success) {
+        const message = formatZodError(annotationResult.error);
+        this.fileParserLogger.error(
+          this.shape.position.start,
+          `Errors validating type:
 ${message}`
-          );
-        }
-        const extensions2 = extensionsResult2.data;
-        if (Object.keys(extensions2.onestore.invalidate).length > 0 && this.operationType === "query") {
-          this.fileParserLogger.error(
-            this.position,
-            `Cannot use an invalidate extension on a query type adapter`
-          );
-          throw new Error();
-        }
-        return {
-          statusCode: response.statusCode.value(),
-          headers: this.buildParams(response.headers),
-          payloads: this.buildPayloads(response),
-          invalidation: extensions2.onestore.invalidate
+        );
+        throw new Error();
+      }
+      if ((_a = annotationResult.data.onestore) == null ? void 0 : _a.key) {
+        this.parsedExtensions = {
+          type: "identifiable",
+          ...annotationResult.data.onestore
         };
       }
-      return {
-        statusCode: response.statusCode.value(),
-        headers: this.buildParams(response.headers),
-        payloads: this.buildPayloads(response)
-      };
-    });
+      this.logger.trace("Running this types resolution");
+      this.typeResolve();
+    } else {
+      this.logger.trace("Type was already resolved");
+    }
   }
-  get cacheStrategy() {
-    return this.parsedCacheStrategy;
+  /*
+  Placeholder for type specific resolution
+  */
+  typeResolve() {
   }
-  buildPayloads(r) {
-    return r.payloads.map((payload) => {
+  get extensions() {
+    if (this.parsedExtensions.type === "identifiable") {
+      const CACHE_CONTROL = "cache-control";
+      const defaults = this.api.defaults.typeCacheControl;
       return {
-        mediaType: payload.mediaType.value(),
-        data: this.amfTypeFactory(
-          {},
-          payload.schema,
-          this.typeRegistry,
-          this.logger,
-          this.fileParserLogger,
-          true
-        )
+        ...this.parsedExtensions,
+        [CACHE_CONTROL]: {
+          ...defaults,
+          ...this.parsedExtensions[CACHE_CONTROL]
+        }
       };
-    });
+    } else {
+      return this.parsedExtensions;
+    }
   }
-  getDefaultValue(param) {
-    var _a, _b;
-    const defaultValue = (_a = param.schema) == null ? void 0 : _a.defaultValue;
-    if (defaultValue) {
-      return (_b = defaultValue.value) == null ? void 0 : _b.value();
+}
+class AMFAnyTypeImpl extends AMFBaseType {
+  constructor() {
+    super(...arguments);
+    this.type = "any";
+  }
+}
+class AMFObjectTypeImpl extends AMFBaseType {
+  constructor() {
+    super(...arguments);
+    this.type = "object";
+    this.properties = {};
+    this.resolved = false;
+    this.additionalProperties = { type: "any" };
+  }
+  typeResolve() {
+    var _a;
+    if (((_a = this.shape.values) == null ? void 0 : _a.length) > 0) {
+      this.fileParserLogger.error(
+        this.shapePosition,
+        `Type Error (${this.shape.name.value()}). Object type may not specify enum property.`
+      );
+      throw new Error();
+    }
+    this.logger.trace("Resolving properties");
+    this.resolveProperties();
+    this.logger.trace("Resolving additional properties");
+    this.resolveAdditionalProperties();
+  }
+  resolveProperties() {
+    for (const property of this.shape.properties) {
+      const propertyName = property.name.value();
+      const type = this.factory(
+        this.api,
+        property.range,
+        this.typeRegistry,
+        this.logger,
+        this.fileParserLogger,
+        true
+      );
+      type.resolve();
+      const propertyType = {
+        type,
+        required: property.minCount.value() !== 0
+      };
+      this.properties[propertyName] = propertyType;
     }
   }
-  buildParams(p) {
-    const params = {};
-    p.forEach((param) => {
-      params[`${param.name.value()}`] = {
-        required: param.required.value(),
-        type: this.amfTypeFactory(
-          {},
-          param.schema,
-          this.typeRegistry,
-          this.logger,
-          this.fileParserLogger,
-          true
-        ),
-        explode: param.explode.value(),
-        defaultValue: this.getDefaultValue(param)
+  resolveAdditionalProperties() {
+    if (this.shape.closed.value()) {
+      this.additionalProperties = {
+        type: "not",
+        not: { type: "any" }
       };
-    });
-    return params;
+    } else if (this.shape.additionalPropertiesSchema) {
+      this.additionalProperties = this.factory(
+        this.api,
+        this.shape.additionalPropertiesSchema,
+        this.typeRegistry,
+        this.logger,
+        this.fileParserLogger,
+        true
+      );
+    }
   }
 }
-class AmfHttpOperation extends AmfBaseOperation {
+class AMFNilTypeImpl extends AMFBaseType {
   constructor() {
     super(...arguments);
-    this.type = "http";
+    this.type = "nil";
   }
 }
-class AmfHttpOperationWithRequestBody extends AmfBaseOperation {
-  constructor(amfOperation, amfTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
-    super(
-      amfOperation,
-      amfTypeFactory2,
-      typeRegistry,
-      logger,
-      fileParserLogger,
-      endpoint,
-      server
+class AMFNotTypeImpl extends AMFBaseType {
+  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
+    super(api, shape, typeRegistry, factory, logger, fileParserLogger);
+    this.shape = shape;
+    this.typeRegistry = typeRegistry;
+    this.factory = factory;
+    this.logger = logger;
+    this.fileParserLogger = fileParserLogger;
+    this.type = "not";
+    const amfType = this.factory(
+      this.api,
+      this.shape.not,
+      this.typeRegistry,
+      this.logger,
+      this.fileParserLogger
     );
-    this.type = "http";
-    const hasRequestBody = amfOperation.requests.some((request) => request.payloads.length > 0);
-    if (!hasRequestBody) {
-      throw new Error("Operation must have a request body defined");
-    }
-    this.method = amfOperation.method.value().toUpperCase();
-    const extensionsRaw = extractExtensions(amfOperation.customDomainProperties);
-    const extensionsResult = this.operationSchemaBuilder.buildHttpOperationSchema().default({}).safeParse(extensionsRaw);
-    if (!extensionsResult.success) {
-      const message = formatZodError(extensionsResult.error);
-      this.fileParserLogger.error(
-        this.amfOperation.position.start,
-        `Error validating aura operation:
-${message}`
-      );
-      throw new Error();
-    }
-    const extensions = extensionsResult.data;
-    if (!extensions.onestore.config["body-param"]) {
-      throw new Error("Missing body-param");
-    }
-    this.configBodyParam = extensions.onestore.config["body-param"];
+    amfType.resolve();
+    this.not = amfType;
   }
 }
-class AmfAuraOperation extends AmfBaseOperation {
-  constructor(amfOperation, amfTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
-    super(
-      amfOperation,
-      amfTypeFactory2,
-      typeRegistry,
-      logger,
-      fileParserLogger,
-      endpoint,
-      server
+class AMFAllOfTypeImpl extends AMFBaseType {
+  constructor() {
+    super(...arguments);
+    this.type = "allOf";
+    this.allOf = [];
+  }
+  typeResolve() {
+    this.logger.trace("Running resolution for inherited and composed shapes");
+    const allOfTypes = [...this.shape.inherits, ...this.shape.and].map(
+      (inheritedShape) => {
+        return this.factory(
+          this.api,
+          inheritedShape,
+          this.typeRegistry,
+          this.logger,
+          this.fileParserLogger,
+          true
+        );
+      }
     );
-    this.type = "aura";
-    const hasRequestBody = amfOperation.requests.some((request) => request.payloads.length > 0);
-    if (hasRequestBody) {
-      throw new Error("Operation must not have a request body defined");
+    const rootType = this.factory(
+      this.api,
+      this.shape,
+      this.typeRegistry,
+      this.logger,
+      this.fileParserLogger,
+      true,
+      /* @__PURE__ */ new Set([
+        "any",
+        "ref",
+        "array",
+        "boolean",
+        "date",
+        "number",
+        "datetime",
+        "datetime-only",
+        "double",
+        "integer",
+        "nil",
+        "not",
+        "number",
+        "object",
+        "string",
+        "time"
+      ]),
+      true
+    );
+    this.allOf = [rootType, ...allOfTypes];
+    if (isOneOfShape(this.shape)) {
+      const OneOf = this.factory(
+        this.api,
+        this.shape,
+        this.typeRegistry,
+        this.logger,
+        this.fileParserLogger,
+        true,
+        /* @__PURE__ */ new Set(["oneOf"]),
+        true
+      );
+      this.allOf.push(OneOf);
     }
-    this.method = amfOperation.method.value().toUpperCase();
-    const extensionsRaw = extractExtensions(amfOperation.customDomainProperties);
-    const extensionsResult = this.operationSchemaBuilder.buildAuraOperationSchema().safeParse(extensionsRaw);
-    if (!extensionsResult.success) {
-      const message = formatZodError(extensionsResult.error);
-      this.fileParserLogger.error(
-        this.amfOperation.position.start,
-        `Error validating aura operation:
-${message}`
+    if (isEnumShape(this.shape)) {
+      const enumType2 = this.factory(
+        this.api,
+        this.shape,
+        this.typeRegistry,
+        this.logger,
+        this.fileParserLogger,
+        true,
+        /* @__PURE__ */ new Set(["enum"]),
+        true
       );
-      throw new Error();
+      this.allOf.push(enumType2);
     }
-    const extensions = extensionsResult.data;
-    this.aura = { methodName: extensions.onestore.config.aura.method };
+    this.validateDiscriminators();
   }
-}
-class AmfAuraOperationWithRequestBody extends AmfBaseOperation {
-  constructor(amfOperation, amfTypeFactory2, typeRegistry, logger, fileParserLogger, endpoint, server) {
-    super(
-      amfOperation,
-      amfTypeFactory2,
-      typeRegistry,
-      logger,
-      fileParserLogger,
-      endpoint,
-      server
-    );
-    this.type = "aura";
-    const hasRequestBody = amfOperation.requests.some((request) => request.payloads.length > 0);
-    if (!hasRequestBody) {
-      throw new Error("Operation must have a request body defined");
+  includes(t) {
+    return this.allOf.some((parent) => {
+      const canonicalizedParent = canonicalizeType(parent);
+      if (canonicalizedParent === t) {
+        return true;
+      }
+      return canonicalizedParent.type === "allOf" && canonicalizedParent.includes(t);
+    });
+  }
+  get discriminatedParent() {
+    var _a;
+    const discriminatedParents = [
+      ...bfs(
+        [this],
+        (type) => {
+          return isDiscriminatedObjectType(type);
+        },
+        (type) => {
+          return type.type === "allOf" ? type.allOf : type.type === "ref" ? [type.$ref] : [];
+        }
+      ).values()
+    ];
+    if (discriminatedParents.length === 0) {
+      return;
     }
-    this.method = amfOperation.method.value().toUpperCase();
-    const extensionsRaw = extractExtensions(amfOperation.customDomainProperties);
-    const extensionsResult = this.operationSchemaBuilder.buildAuraOperationWithBodySchema().safeParse(extensionsRaw);
-    if (!extensionsResult.success) {
-      const message = formatZodError(extensionsResult.error);
+    if (discriminatedParents.length > 1) {
+      const { line = 0, column = 0 } = ((_a = this.shape.position) == null ? void 0 : _a.start) || {};
       this.fileParserLogger.error(
-        this.amfOperation.position.start,
-        `Error validating aura operation:
-${message}`
+        { line, column },
+        `Type ${this.typeRegistry.nameOf(
+          this
+        )} cannot inherit from multiple discriminated objects. Inherits from ${discriminatedParents.map(
+          (parent) => this.typeRegistry.nameOf(parent)
+        )}.`
       );
       throw new Error();
     }
-    const extensions = extensionsResult.data;
-    if (extensions.onestore.config["body-param"] === void 0) {
-      throw new Error("Missing body param");
-    }
-    if (extensions.onestore.config.aura["body-param"] === void 0) {
-      throw new Error("Missing aura body param");
-    }
-    this.configBodyParam = extensions.onestore.config["body-param"];
-    this.aura = {
-      methodName: extensions.onestore.config.aura.method,
-      bodyParam: extensions.onestore.config.aura["body-param"]
-    };
+    return discriminatedParents[0];
+  }
+  validateDiscriminators() {
+    this.discriminatedParent;
   }
-}
-function AmfGraphQLOperationMixin(Base) {
-  return class AmfGraphQLOperation extends Base {
-    constructor(...args) {
-      super(...args);
-      this.operationType = "graphql";
-      this.graphqlConfig = this.setupGraphQLConfig();
+  get extensions() {
+    var _a, _b;
+    if (super.extensions.type === "identifiable") {
+      return super.extensions;
     }
-    setupGraphQLConfig() {
-      const extensionsRaw = extractExtensions(this.amfOperation.customDomainProperties);
-      const extensionsResult = this.operationSchemaBuilder.buildGraphQLOperationSchema().safeParse(extensionsRaw);
-      if (!extensionsResult.success) {
-        const message = formatZodError(extensionsResult.error);
-        this.fileParserLogger.error(
-          this.amfOperation.position.start,
-          `Error validating graphql operation:
-${message}`
-        );
-        throw new Error(message);
-      }
-      const extensions = extensionsResult.data;
-      const config = {
-        schemaFilePath: extensions.onestore.config.graphql.schema,
-        "type-metadata": extensions.onestore.config.graphql["type-metadata"]
-      };
-      return config;
+    if (((_b = (_a = this.discriminatedParent) == null ? void 0 : _a.extensions) == null ? void 0 : _b.type) === "identifiable") {
+      return this.discriminatedParent.extensions;
     }
-  };
+    return super.extensions;
+  }
 }
-const endpointSchema = z.object({
-  onestore: z.discriminatedUnion("endpoint-type", [
-    z.object({
-      "endpoint-type": z.literal("http")
-    }).strict(),
-    z.object({
-      "endpoint-type": z.literal("aura"),
-      config: z.object({
-        aura: z.object({
-          controller: z.string()
-        })
-      }),
-      "network-preference": z.enum(["aura", "http"]).default("aura")
-    }).strict()
-  ]).optional()
-});
-const partialOperationSchema = z.object({
-  onestore: z.object({
-    config: z.object({
-      "operation-type": z.enum(["query", "mutation", "graphql"]).optional()
-    }).passthrough().optional()
-  }).passthrough().optional()
-});
-function createAmfAuraEndpoint(amfEndpoint, amfTypeFactory2, typeRegistry, logger, fileParserLogger, server, api, networkPreference) {
-  const endpoint = new AmfAuraEndpoint(
-    amfEndpoint,
-    [],
-    amfTypeFactory2,
-    typeRegistry,
-    logger,
-    fileParserLogger,
-    api,
-    networkPreference
-  );
-  const operations = amfEndpoint.operations.map((operation) => {
-    var _a, _b;
-    const extensionsRaw = extractExtensions(operation.customDomainProperties);
-    const operationConfigValidationResult = partialOperationSchema.safeParse(extensionsRaw);
-    if (!operationConfigValidationResult.success) {
-      const message = formatZodError(operationConfigValidationResult.error);
-      fileParserLogger.error(
-        operation.position.start,
-        `Errors validating operation:
-${message}`
+class AMFEnumerableScalarType extends AMFBaseType {
+  typeResolve() {
+    var _a;
+    if (((_a = this.shape.values) == null ? void 0 : _a.length) > 0) {
+      this.values = getEnumValuesFromShape(this.shape);
+    }
+    if (this.parsedExtensions.type === "identifiable") {
+      this.fileParserLogger.error(
+        this.shape.position.start,
+        `${this.shape.name} is scalar and thus cannot be made identifiable by specifying a key`
       );
       throw new Error();
     }
-    const hasRequestBody = operation.requests.some((request) => request.payloads.length > 0);
-    const isGraphQLOperation = ((_b = (_a = operationConfigValidationResult.data.onestore) == null ? void 0 : _a.config) == null ? void 0 : _b["operation-type"]) === "graphql";
-    let baseClass = isGraphQLOperation ? AmfGraphQLOperationMixin(
-      hasRequestBody ? AmfAuraOperationWithRequestBody : AmfAuraOperation
-    ) : hasRequestBody ? AmfAuraOperationWithRequestBody : AmfAuraOperation;
-    return new baseClass(
-      operation,
-      amfTypeFactory2,
-      typeRegistry,
-      logger,
-      fileParserLogger,
-      endpoint,
-      server
-    );
-  });
-  endpoint.operations = operations;
-  return endpoint;
+  }
 }
-function createAmfHttpEndpoint(amfEndpoint, amfTypeFactory2, typeRegistry, logger, fileParserLogger, server, api) {
-  const endpoint = new AmfHttpEndPoint(
-    amfEndpoint,
-    [],
-    amfTypeFactory2,
-    typeRegistry,
-    logger,
-    fileParserLogger,
-    api
-  );
-  const operations = amfEndpoint.operations.map((operation) => {
-    var _a, _b;
-    const operationConfigValidationResult = partialOperationSchema.safeParse(
-      extractExtensions(operation.customDomainProperties)
-    );
-    if (!operationConfigValidationResult.success) {
-      const message = formatZodError(operationConfigValidationResult.error);
-      const errorMessage = `Error validating operation:
-${message}`;
-      fileParserLogger.error(operation.position.start, errorMessage);
-      throw new Error(errorMessage);
-    }
-    const hasRequestBody = operation.requests.some((request) => request.payloads.length > 0);
-    const isGraphQLOperation = ((_b = (_a = operationConfigValidationResult.data.onestore) == null ? void 0 : _a.config) == null ? void 0 : _b["operation-type"]) === "graphql";
-    let baseClass = isGraphQLOperation ? AmfGraphQLOperationMixin(
-      hasRequestBody ? AmfHttpOperationWithRequestBody : AmfHttpOperation
-    ) : hasRequestBody ? AmfHttpOperationWithRequestBody : AmfHttpOperation;
-    return new baseClass(
-      operation,
-      amfTypeFactory2,
-      typeRegistry,
-      logger,
-      fileParserLogger,
-      endpoint,
-      server
-    );
-  });
-  endpoint.operations = operations;
-  return endpoint;
+class AMFBooleanTypeImpl extends AMFEnumerableScalarType {
+  constructor() {
+    super(...arguments);
+    this.type = "boolean";
+  }
 }
-function amfEndpointFactory(amfEndpoint, amfTypeFactory2, typeRegistry, logger, fileParserLogger, server, api) {
-  const endpointConfigValidationResult = endpointSchema.safeParse(
-    extractExtensions(amfEndpoint.customDomainProperties)
-  );
-  if (!endpointConfigValidationResult.success) {
-    const message = formatZodError(endpointConfigValidationResult.error);
-    const errorMessage = `Error validating endpoint:
-${message}`;
-    fileParserLogger.error(amfEndpoint.position.start, errorMessage);
-    throw new Error(errorMessage);
+class AMFDoubleTypeImpl extends AMFEnumerableScalarType {
+  constructor() {
+    super(...arguments);
+    this.type = "double";
   }
-  const config = endpointConfigValidationResult.data;
-  if (config.onestore === void 0) {
-    return void 0;
+}
+class AMFIntegerTypeImpl extends AMFEnumerableScalarType {
+  constructor() {
+    super(...arguments);
+    this.type = "integer";
   }
-  const endpoint = config.onestore["endpoint-type"] === "aura" ? createAmfAuraEndpoint(
-    amfEndpoint,
-    amfTypeFactory2,
-    typeRegistry,
-    logger,
-    fileParserLogger,
-    server,
-    api,
-    config.onestore["network-preference"]
-  ) : createAmfHttpEndpoint(
-    amfEndpoint,
-    amfTypeFactory2,
-    typeRegistry,
-    logger,
-    fileParserLogger,
-    server,
-    api
-  );
-  if (!validateUniqueBindingIdentfiers(endpoint.operations)) {
-    const errorMessage = `All operations must have unique bindings`;
-    fileParserLogger.error(amfEndpoint.position.start, errorMessage);
-    throw new Error(errorMessage);
+}
+class AMFNumberTypeImpl extends AMFEnumerableScalarType {
+  constructor() {
+    super(...arguments);
+    this.type = "number";
+  }
+}
+class AMFStringTypeImpl extends AMFEnumerableScalarType {
+  constructor() {
+    super(...arguments);
+    this.type = "string";
+  }
+}
+class AMFDateTypeImpl extends AMFEnumerableScalarType {
+  constructor() {
+    super(...arguments);
+    this.type = "date";
+  }
+}
+const DATE = "date";
+const DATE_TIME = "date-time";
+class AMFDateTimeImpl extends AMFEnumerableScalarType {
+  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
+    super(api, shape, typeRegistry, factory, logger, fileParserLogger);
+    this.shape = shape;
+    this.type = "datetime";
+    const formatValue = shape.format.value();
+    this.format = formatValue === DATE ? DATE : DATE_TIME;
+  }
+}
+class AMFOneOfTypeImpl extends AMFBaseType {
+  constructor() {
+    super(...arguments);
+    this.type = "oneOf";
+    this.oneOf = [];
+  }
+  typeResolve() {
+    var _a;
+    let { anyOf = [], xone = [] } = this.shape;
+    this.oneOf = [...anyOf, ...xone].map((subTypeShape) => {
+      const subType = this.factory(
+        this.api,
+        subTypeShape,
+        this.typeRegistry,
+        this.logger,
+        this.fileParserLogger
+      );
+      subType.resolve();
+      return subType;
+    });
+    if (((_a = this.shape.values) == null ? void 0 : _a.length) > 0) {
+      this.values = getEnumValuesFromShape(this.shape);
+    }
+    this.preserveIdentifiableExtensionsFromNullablePattern();
+  }
+  /**
+   * When AMF encounters 'nullable: true' on an object with identifiable extensions,
+   * it converts it to a oneOf with [object, null]. This method detects this pattern
+   * and preserves the identifiable extensions from the object member on the union.
+   */
+  preserveIdentifiableExtensionsFromNullablePattern() {
+    var _a;
+    if (this.oneOf.length !== 2) {
+      return;
+    }
+    const nullMember = this.oneOf.find((member) => member.type === "nil");
+    const objectMember = this.oneOf.find((member) => member.type === "object");
+    if (!nullMember || !objectMember) {
+      return;
+    }
+    if (((_a = objectMember.extensions) == null ? void 0 : _a.type) === "identifiable") {
+      this.parsedExtensions = { ...objectMember.extensions };
+    }
   }
-  return endpoint;
 }
-class AmfBaseEndpoint {
-  constructor(amfEndpoint, operations, amfTypeFactory2, typeRegistry, logger, fileParserLogger, api) {
-    this.amfEndpoint = amfEndpoint;
-    this.operations = operations;
+class AMFEnumTypeImpl extends AMFBaseType {
+  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
+    super(api, shape, typeRegistry, factory, logger, fileParserLogger);
+    this.shape = shape;
+    this.typeRegistry = typeRegistry;
+    this.factory = factory;
     this.logger = logger;
     this.fileParserLogger = fileParserLogger;
-    this.api = api;
-    this.path = this.amfEndpoint.path.value();
-    this.uriParameters = {};
-    this.amfEndpoint.parameters.forEach((param) => {
-      this.uriParameters[`${param.name}`] = {
-        required: param.required.value(),
-        type: amfTypeFactory2(
-          this.api,
-          param.schema,
-          typeRegistry,
-          logger,
-          fileParserLogger,
-          true
-        ),
-        explode: param.explode.value()
-      };
-    });
+    this.type = "enum";
+    this.values = [];
+    this.values = getEnumValuesFromShape(shape);
   }
 }
-class AmfHttpEndPoint extends AmfBaseEndpoint {
+class AMFRefTypeImpl extends AMFBaseType {
   constructor() {
     super(...arguments);
-    this.type = "http";
+    this.type = "ref";
+    this.$ref = {
+      type: "not",
+      not: { type: "any" }
+    };
+    this.resolved = false;
+  }
+  typeResolve() {
+    this.logger.trace(`Resolving $ref at ${this.shape.id.split("#")[1]}`);
+    if (this.shape.isLink && this.shape.linkTarget) {
+      const inheritedType = this.typeRegistry.get(this.shape.linkLabel.toString());
+      if (inheritedType) {
+        this.logger.trace(`Found ${inheritedType.shape.name} for $ref`);
+        inheritedType.resolve();
+        this.$ref = inheritedType;
+      } else {
+        const errorMessage = `Failed to resolve $ref: ${this.shape.linkLabel.toString()} from ${this.shape.id}`;
+        this.fileParserLogger.error(this.shapePosition, errorMessage);
+        throw new Error(errorMessage);
+      }
+    }
   }
 }
-class AmfAuraEndpoint extends AmfBaseEndpoint {
-  constructor(amfEndPoint, operations, amfTypeFactory2, typeRegistry, logger, fileParserLogger, api, networkPreference) {
-    super(amfEndPoint, operations, amfTypeFactory2, typeRegistry, logger, fileParserLogger, api);
+class AMFDiscriminatedObjectTypeImpl extends AMFBaseType {
+  constructor(api, shape, typeRegistry, factory, logger, fileParserLogger) {
+    super(api, shape, typeRegistry, factory, logger, fileParserLogger);
+    this.shape = shape;
+    this.typeRegistry = typeRegistry;
+    this.factory = factory;
     this.logger = logger;
     this.fileParserLogger = fileParserLogger;
-    this.api = api;
-    this.networkPreference = networkPreference;
-    this.type = "aura";
-    this.auraController = this.buildAuraController();
-  }
-  buildAuraController() {
-    const configResult = endpointSchema.safeParse(
-      extractExtensions(this.amfEndpoint.customDomainProperties)
+    this.type = "discriminatedObject";
+    this._mapping = void 0;
+    if (this.shape.discriminator.isNullOrEmpty) {
+      this.fileParserLogger.error(
+        this.shapePosition,
+        "Supplied shape does not provide a discriminator"
+      );
+      throw new Error();
+    }
+    this.discriminator = this.shape.discriminator.value();
+    this.baseType = factory(
+      api,
+      shape,
+      typeRegistry,
+      logger,
+      fileParserLogger,
+      false,
+      /* @__PURE__ */ new Set(["object"])
     );
-    if (!configResult.success) {
-      const message = formatZodError(configResult.error);
-      const errorMessage = `Error validating aura endpoint:
-${message}`;
-      this.fileParserLogger.error(this.amfEndpoint.position.start, errorMessage);
-      throw new Error(errorMessage);
+  }
+  typeResolve() {
+    this.baseType.resolve();
+    if (this.typeRegistry.nameOf(this) === void 0) {
+      this.fileParserLogger.error(
+        this.shapePosition,
+        "Cannot use discriminator on inline types."
+      );
+      throw new Error();
     }
-    const config = configResult.data;
-    if (!config.onestore || config.onestore["endpoint-type"] !== "aura") {
-      throw new Error("invalid config");
+  }
+  get mapping() {
+    if (this._mapping === void 0) {
+      this._mapping = {};
+      this.resolveDiscriminator();
     }
-    const name = config.onestore.config.aura.controller;
-    if (name === void 0) {
-      throw new Error("Aura controller name must be defined for an Aura endpoint.");
+    return this._mapping;
+  }
+  resolveDiscriminator() {
+    this.buildExplicitMapping();
+    this.buildImplicitMapping();
+  }
+  /**
+   * Adds implicit discriminator values (i.e., type names) as mappings to types
+   *
+   * @private
+   */
+  buildImplicitMapping() {
+    const oneOfNames = this.shape.xone.reduce((result, shape) => {
+      if (shape.isLink) {
+        result.push(shape.linkLabel.value());
+      }
+      return result;
+    }, []);
+    this.typeRegistry.forEach((type, name) => {
+      type.resolve();
+      if ((type.type === "allOf" && type.includes(this) || oneOfNames.includes(name)) && !Object.values(this._mapping).includes(type)) {
+        this._mapping[name] = type;
+      }
+    });
+  }
+  /**
+   * Adds explicit discriminator values as mappings to types
+   *
+   * @private
+   */
+  buildExplicitMapping() {
+    this.shape.discriminatorMapping.forEach((el) => {
+      const value = el.templateVariable.value();
+      const linkExpressionSplit = el.linkExpression.value().split("/");
+      const typeName = linkExpressionSplit[linkExpressionSplit.length - 1];
+      const type = this.typeRegistry.get(typeName);
+      if (type === void 0) {
+        this.fileParserLogger.error(this.shapePosition, `Cannot find type ${typeName}`);
+        throw new Error();
+      }
+      this._mapping[value] = type;
+    });
+  }
+}
+function amfTypeFactory(api, shape, typeRegistry, logger, fileParserLogger, resolve = false, allowedTypes = void 0, skipRegistry = false) {
+  var _a;
+  if (!skipRegistry) {
+    for (const [_, type] of typeRegistry.entries()) {
+      if (shape.id === type.shape.id) {
+        return type;
+      }
+    }
+  }
+  const { line = 0, column = 0 } = ((_a = shape.position) == null ? void 0 : _a.start) || {};
+  let ctor;
+  if (isAnyOfShape(shape)) {
+    fileParserLogger.error(
+      { line, column },
+      `anyOf is not suppoort, found in type ${shape.name.value()}`
+    );
+    throw new Error();
+  }
+  if (isRefShape(shape)) {
+    ctor = AMFRefTypeImpl;
+  } else if ((!allowedTypes || allowedTypes.has("allOf")) && isAllOfShape(shape)) {
+    ctor = AMFAllOfTypeImpl;
+  } else if ((!allowedTypes || allowedTypes.has("oneOf")) && isOneOfShape(shape)) {
+    ctor = AMFOneOfTypeImpl;
+  } else if ((!allowedTypes || allowedTypes.has("enum")) && isEnumShape(shape)) {
+    ctor = AMFEnumTypeImpl;
+  } else if ((!allowedTypes || allowedTypes.has("nil")) && isNilShape(shape)) {
+    ctor = AMFNilTypeImpl;
+  } else if (isScalarShape(shape) && shape.dataType.value() in DATATYPE_TO_SCALAR_TYPE && (!allowedTypes || allowedTypes.has(DATATYPE_TO_SCALAR_TYPE[shape.dataType.value()]))) {
+    const scalarType = DATATYPE_TO_SCALAR_TYPE[shape.dataType.value()];
+    switch (scalarType) {
+      case "string":
+        ctor = AMFStringTypeImpl;
+        break;
+      case "number":
+        ctor = AMFNumberTypeImpl;
+        break;
+      case "boolean":
+        ctor = AMFBooleanTypeImpl;
+        break;
+      case "double":
+        ctor = AMFDoubleTypeImpl;
+        break;
+      case "integer":
+        ctor = AMFIntegerTypeImpl;
+        break;
+      case "date":
+        ctor = AMFDateTypeImpl;
+        break;
+      case "datetime":
+        ctor = AMFDateTimeImpl;
+        break;
+      default:
+        fileParserLogger.error(
+          { line, column },
+          `type of shape ${shape.name.value()} not recognized`
+        );
+        throw new Error();
+    }
+  } else if ((!allowedTypes || allowedTypes.has("discriminatedObject")) && isNodeShape(shape) && !shape.discriminator.isNullOrEmpty) {
+    ctor = AMFDiscriminatedObjectTypeImpl;
+  } else if ((!allowedTypes || allowedTypes.has("object")) && isNodeShape(shape)) {
+    ctor = AMFObjectTypeImpl;
+  } else if ((!allowedTypes || allowedTypes.has("array")) && isArrayShape(shape)) {
+    ctor = AMFArrayTypeImpl;
+  } else if ((!allowedTypes || allowedTypes.has("not")) && isNotShape(shape)) {
+    ctor = AMFNotTypeImpl;
+  } else if ((!allowedTypes || allowedTypes.has("any")) && isAnyShape(shape)) {
+    ctor = AMFAnyTypeImpl;
+  } else {
+    fileParserLogger.error(
+      { line, column },
+      `type of shape ${shape.name.value()} not recognized`
+    );
+    throw new Error();
+  }
+  const result = new ctor(api, shape, typeRegistry, amfTypeFactory, logger, fileParserLogger);
+  if (resolve) {
+    result.resolve();
+  }
+  return result;
+}
+class AMFArrayTypeImpl extends AMFBaseType {
+  constructor() {
+    super(...arguments);
+    this.type = "array";
+    this.items = { type: "any" };
+  }
+  typeResolve() {
+    if (this.shape.items) {
+      const items = amfTypeFactory(
+        this.api,
+        this.shape.items,
+        this.typeRegistry,
+        this.logger,
+        this.fileParserLogger
+      );
+      items.resolve();
+      this.items = items;
     }
-    return { name };
   }
 }
-const rootSchema = z.object({
-  onestore: z.object({
-    version: z.string().refine(stringIsVersion, () => {
-      return {
-        message: "Version must satisfy format major[.minor[.patch]]"
-      };
-    })
-  })
-});
 function getAmfAnnotationVersion(webApi) {
   const configRaw = extractExtensions(webApi.customDomainProperties);
-  const config = rootSchema.safeParse(configRaw);
+  const config = rootExtensionSchema.safeParse(configRaw);
   if (!config.success) {
     const validationMessage = formatZodError(config.error);
     throw new Error(`Error validating root x-onestore extension:
@@ -6773,28 +7088,6 @@ ${formattedValidation}`;
   }
   return isValid2;
 }
-const V1_VERSION = "1.0.0";
-const oneStoreExtensionsSchema = z.object({
-  onestore: z.object({
-    defaults: z.object({
-      operations: z.object({
-        "cache-strategy": z.discriminatedUnion("type", [
-          z.object({ type: z.literal("none") }).strict(),
-          z.object({ type: z.literal("resource") }).strict(),
-          z.object({ type: z.literal("normalized") }).strict()
-        ])
-      }),
-      schemas: z.object({
-        "cache-control": cacheControl
-      })
-    }).partial().strict().optional(),
-    // Allow service catalog at root-level for reliability
-    services: servicesCatalogSchema.optional(),
-    namespace: z.string().optional(),
-    version: z.string()
-  }).strict()
-});
-const ANONYMOUS_TYPE_NAME = "<anonymous>";
 class AMFAPI {
   constructor(document, services, fileParserlogger) {
     this.document = document;
@@ -6840,381 +7133,126 @@ class AMFAPI {
     if (this.webApi.servers.length === 0) {
       this.fileParserlogger.error(
         { line: this.webApi.position.lineFrom, column: this.webApi.position.columnFrom },
-        `At least one server must be specified in your OpenAPI file. e.g.:
-servers:
-  - url: http://localhost:3000
-    description: Local development server`
-      );
-      throw new Error();
-    }
-    this._servers = this.webApi.servers.map((s) => {
-      const uriParameters = {};
-      s.variables.forEach((param) => {
-        uriParameters[`${param.name.value()}`] = {
-          required: param.required.value(),
-          type: amfTypeFactory(
-            this,
-            param.schema,
-            this.types,
-            this.services.logger,
-            this.fileParserlogger
-          ),
-          explode: param.explode.value()
-        };
-      });
-      return {
-        url: s.url.value(),
-        uriParameters
-      };
-    });
-  }
-  buildTypes() {
-    this.services.logger.debug("AMFAPI - Building the type registry");
-    const typeRegistry = this.typeRegistry = new BaseTypeRegistry();
-    this.document.declares.filter(isTypeShape).forEach((shape) => {
-      const name = shape.name.value();
-      this.services.logger.debug(`AMFAPI - Building AMF Type for ${name}`);
-      const amfType = amfTypeFactory(
-        this,
-        shape,
-        typeRegistry,
-        this.services.logger,
-        this.fileParserlogger
-      );
-      this.services.logger.debug(`AMFAPI - Setting ${name} in type registry`);
-      typeRegistry.set(shape.name.value(), amfType);
-    });
-    typeRegistry.forEach((type, name) => {
-      this.services.logger.debug(`AMFAPI - Resolving type ${name}`);
-      type.resolve();
-    });
-  }
-  get webApi() {
-    return this.document.encodes;
-  }
-  get endpoints() {
-    this.build();
-    return this._endpoints;
-  }
-  get defaults() {
-    const operationCacheStrategy2 = this.parsedDefaultOperationCacheStrategyType ?? { type: "none" };
-    const typeCacheControl = this.parsedDefaultTypeCacheControl;
-    const services = resolveDefaultServiceOverrides(this.serviceOverrides);
-    return {
-      operationCacheStrategy: operationCacheStrategy2,
-      typeCacheControl,
-      services
-    };
-  }
-  get servers() {
-    this.build();
-    return this._servers;
-  }
-  get types() {
-    this.build();
-    return this.typeRegistry;
-  }
-  get namespace() {
-    if (this.parsedNamespace === void 0) {
-      return this.defaultedNamespace;
-    }
-    return this.parsedNamespace;
-  }
-  checkAnnotationsVersion() {
-    const version = getAmfAnnotationVersion(this.webApi);
-    if (!satisfies(V1_VERSION, version)) {
-      throw new Error(
-        `Version ${version} requested cannot be satisfied by version ${V1_VERSION} of the AMF API.`
-      );
-    }
-  }
-  setRootLevelAnnotations() {
-    var _a, _b, _c, _d;
-    const extensionsRaw = extractExtensions(this.webApi.customDomainProperties);
-    const oneStoreExtensionsResult = oneStoreExtensionsSchema.safeParse(extensionsRaw);
-    if (!oneStoreExtensionsResult.success) {
-      const message = formatZodError(oneStoreExtensionsResult.error);
-      throw new Error(message);
-    }
-    const onestore = oneStoreExtensionsResult.data.onestore;
-    this.parsedDefaultOperationCacheStrategyType = (_b = (_a = onestore == null ? void 0 : onestore.defaults) == null ? void 0 : _a.operations) == null ? void 0 : _b["cache-strategy"];
-    this.parsedDefaultTypeCacheControl = (_d = (_c = onestore == null ? void 0 : onestore.defaults) == null ? void 0 : _c.schemas) == null ? void 0 : _d["cache-control"];
-    this.parsedNamespace = onestore == null ? void 0 : onestore.namespace;
-    if (this.parsedNamespace === void 0) {
-      this.services.logger.warn(
-        `AMFAPI - namespace is missing, will be defaulted "${this.defaultedNamespace}".`
-      );
-    }
-    if (onestore == null ? void 0 : onestore.services) {
-      this.serviceOverrides = validateAndNormalizeCatalog(onestore.services);
-    }
-  }
-  /**
-   * Validates all endpoints and types.  A validation error will be thrown if any are invalid.
-   *
-   * @protected
-   */
-  validate() {
-    if (!isValidAmfAPI(this, this.fileParserlogger)) {
-      throw new Error("API OneStore configuration failed validation");
-    }
-  }
-}
-class NoNormalizedTypesValidator {
-  constructor(types) {
-    this.types = types;
-  }
-  validate(operation) {
-    if (isNormalizedOperation(operation)) {
-      return ok([]);
-    }
-    const identifiableTypes = /* @__PURE__ */ new Set();
-    operation.responses.forEach((response) => {
-      return response.payloads.forEach((payload) => {
-        this.findNestedIdentifiableTypes(payload.data).forEach(
-          (type) => identifiableTypes.add(type)
-        );
-      });
-    });
-    const messages = [];
-    if (identifiableTypes.size > 0) {
-      identifiableTypes.forEach((type) => {
-        const typeName = this.types.nameOf(type) || ANONYMOUS_TYPE_NAME;
-        messages.push(
-          getFormattedMessage(
-            operation,
-            `Operation ${operation.operationId ? `${operation.operationId} ` : ``}is not normalized but references the normalized type ${typeName} in its response`
-          )
-        );
-      });
-      return messages.length === 0 ? ok([]) : err(messages);
-    }
-    return ok([]);
-  }
-  /**
-   * Completes a breadth-first search of a Type to locate any nested types that are identifiable.
-   *
-   * @returns a Set of all nested types that are identifiable.
-   * @param start
-   * @protected
-   */
-  findNestedIdentifiableTypes(start) {
-    return bfs(
-      [start],
-      (type) => {
-        var _a;
-        return ((_a = type.extensions) == null ? void 0 : _a.type) === "identifiable";
-      },
-      (type) => {
-        const typing = type.type;
-        switch (typing) {
-          case "allOf":
-            return type.allOf;
-          case "array":
-            return [type.items];
-          case "object":
-            return [
-              ...Object.values(type.properties).map((property) => property.type),
-              type.additionalProperties
-            ];
-          case "oneOf":
-            return type.oneOf;
-          case "ref":
-            return [type.$ref];
-          case "discriminatedObject":
-            return [...Object.values(type.mapping), type.baseType];
-          case "any":
-          case "enum":
-          case "boolean":
-          case "double":
-          case "integer":
-          case "number":
-          case "string":
-          case "date":
-          case "datetime":
-          case "datetime-only":
-          case "nil":
-          case "not":
-          case "time":
-            return [];
-          default:
-            throw new Error(
-              `${typing} has not been accounted for when searching for nested identifiable types`
-            );
-        }
-      }
-    );
-  }
-}
-class KeyMatchValidator {
-  constructor(types) {
-    this.types = types;
-  }
-  validate(operation) {
-    if (!isNormalizedOperation(operation)) {
-      return ok([]);
+        `At least one server must be specified in your OpenAPI file. e.g.:
+servers:
+  - url: http://localhost:3000
+    description: Local development server`
+      );
+      throw new Error();
     }
-    const operationHasKey = !!operation.cacheStrategy.key;
-    let valid = true;
-    const messages = [];
-    operation.responses.forEach((response) => {
-      response.payloads.forEach((payload) => {
-        var _a, _b;
-        if (((_a = payload.data.extensions) == null ? void 0 : _a.type) === "identifiable") {
-          const typeName = this.types.nameOf(payload.data) || ANONYMOUS_TYPE_NAME;
-          if (!operationHasKey) {
-            valid = false;
-            messages.push(
-              getFormattedMessage(
-                operation,
-                `Operation ${operation.operationId ? `${operation.operationId} ` : ``}is missing a key to match against its ${typeName} response type`
-              )
-            );
-          } else if (!((_b = payload.data.extensions.key) == null ? void 0 : _b.fields)) {
-            valid = false;
-            messages.push(
-              getFormattedMessage(
-                operation,
-                `Operation ${operation.operationId ? `${operation.operationId} ` : ``}has a key but its ${typeName} response type doesn't have one to match against`
-              )
-            );
-          } else if (!deepEquals(
-            Object.keys(operation.cacheStrategy.key || {}),
-            Object.keys(payload.data.extensions.key.fields)
-          )) {
-            valid = false;
-            messages.push(
-              getFormattedMessage(
-                operation,
-                `Operation ${operation.operationId ? `${operation.operationId} ` : ``}and its ${typeName} response type have mismatched keys`
-              )
-            );
-          }
-        }
+    this._servers = this.webApi.servers.map((s) => {
+      const uriParameters = {};
+      s.variables.forEach((param) => {
+        uriParameters[`${param.name.value()}`] = {
+          required: param.required.value(),
+          type: amfTypeFactory(
+            this,
+            param.schema,
+            this.types,
+            this.services.logger,
+            this.fileParserlogger
+          ),
+          explode: param.explode.value()
+        };
       });
+      return {
+        url: s.url.value(),
+        uriParameters
+      };
     });
-    return valid ? ok(messages) : err(messages);
   }
-}
-class BodyDataValidator {
-  constructor(target, keys, keySourcesValidatorSupplier) {
-    this.target = target;
-    this.keys = keys;
-    this.keySourcesValidatorSupplier = keySourcesValidatorSupplier;
+  buildTypes() {
+    this.services.logger.debug("AMFAPI - Building the type registry");
+    const typeRegistry = this.typeRegistry = new BaseTypeRegistry();
+    this.document.declares.filter(isTypeShape).forEach((shape) => {
+      const name = shape.name.value();
+      this.services.logger.debug(`AMFAPI - Building AMF Type for ${name}`);
+      const amfType = amfTypeFactory(
+        this,
+        shape,
+        typeRegistry,
+        this.services.logger,
+        this.fileParserlogger
+      );
+      this.services.logger.debug(`AMFAPI - Setting ${name} in type registry`);
+      typeRegistry.set(shape.name.value(), amfType);
+    });
+    typeRegistry.forEach((type, name) => {
+      this.services.logger.debug(`AMFAPI - Resolving type ${name}`);
+      type.resolve();
+    });
   }
-  validate(operation) {
-    if (this.keys.length === 0) {
-      return ok([]);
-    }
-    const jsonPayload = this.target.payloads.find((p) => p.mediaType === "application/json");
-    if (jsonPayload === void 0) {
-      return err([
-        getFormattedMessage(
-          operation,
-          `Use of 'body' keys requires a json payload: ${operation.method} ${operation.endpoint.path} has none.`
-        )
-      ]);
+  get webApi() {
+    return this.document.encodes;
+  }
+  get endpoints() {
+    this.build();
+    return this._endpoints;
+  }
+  get defaults() {
+    const operationCacheStrategy2 = this.parsedDefaultOperationCacheStrategyType ?? { type: "none" };
+    const typeCacheControl = this.parsedDefaultTypeCacheControl;
+    const services = resolveDefaultServiceOverrides(this.serviceOverrides);
+    return {
+      operationCacheStrategy: operationCacheStrategy2,
+      typeCacheControl,
+      services
+    };
+  }
+  get servers() {
+    this.build();
+    return this._servers;
+  }
+  get types() {
+    this.build();
+    return this.typeRegistry;
+  }
+  get namespace() {
+    if (this.parsedNamespace === void 0) {
+      return this.defaultedNamespace;
     }
-    const result = this.keySourcesValidatorSupplier(this.keys).validate(jsonPayload.data);
-    if (!result.isOk()) {
-      const message = getFormattedMessage(
-        operation,
-        `Invalid body key(s) specified for ${operation.operationId || `${operation.method} ${operation.endpoint.path}`}`
+    return this.parsedNamespace;
+  }
+  checkAnnotationsVersion() {
+    const version = getAmfAnnotationVersion(this.webApi);
+    if (!satisfies(V1_VERSION, version)) {
+      throw new Error(
+        `Version ${version} requested cannot be satisfied by version ${V1_VERSION} of the AMF API.`
       );
-      message.subValidationMessages = result.error;
-      return err([message]);
     }
-    return ok([]);
   }
-}
-function buildOperationValidator(api) {
-  const bodyDateValidatorSupplier = (target, sources) => {
-    return new BodyDataValidator(target, sources, (keys) => {
-      return new KeySourcesValidator(api.types, keys);
-    });
-  };
-  return compose([
-    new InvalidationValidator(api.types, bodyDateValidatorSupplier),
-    new KeySourceValidator(bodyDateValidatorSupplier),
-    new Response200Validator(),
-    new NoNormalizedTypesValidator(api.types),
-    new KeyMatchValidator(api.types)
-  ]);
-}
-function buildEndpointValidator(api) {
-  const operationValidator = buildOperationValidator(api);
-  return {
-    validate(subject) {
-      return combineValidationResults(
-        subject.operations.map((operation) => operationValidator.validate(operation))
+  setRootLevelAnnotations() {
+    var _a, _b, _c, _d;
+    const extensionsRaw = extractExtensions(this.webApi.customDomainProperties);
+    const oneStoreExtensionsResult = baseExtensionsSchema.safeParse(extensionsRaw);
+    if (!oneStoreExtensionsResult.success) {
+      const message = formatZodError(oneStoreExtensionsResult.error);
+      throw new Error(message);
+    }
+    const onestore = oneStoreExtensionsResult.data.onestore;
+    this.parsedDefaultOperationCacheStrategyType = (_b = (_a = onestore == null ? void 0 : onestore.defaults) == null ? void 0 : _a.operations) == null ? void 0 : _b["cache-strategy"];
+    this.parsedDefaultTypeCacheControl = (_d = (_c = onestore == null ? void 0 : onestore.defaults) == null ? void 0 : _c.schemas) == null ? void 0 : _d["cache-control"];
+    this.parsedNamespace = onestore == null ? void 0 : onestore.namespace;
+    if (this.parsedNamespace === void 0) {
+      this.services.logger.warn(
+        `AMFAPI - namespace is missing, will be defaulted "${this.defaultedNamespace}".`
       );
     }
-  };
-}
-class BindingsValidation {
-  constructor() {
-  }
-  validate(api) {
-    const messages = [];
-    const endpoints = api.endpoints;
-    const identToPathAndOperation = /* @__PURE__ */ new Map();
-    for (const endpoint of endpoints) {
-      const { path: path2, operations } = endpoint;
-      for (const operation of operations) {
-        const operationId = operation.operationId || `${operation.method} ${operation.endpoint.path}`;
-        const { bindings } = operation;
-        for (const binding of bindings) {
-          const { identifier } = binding;
-          if (identToPathAndOperation.has(identifier)) {
-            const existing = identToPathAndOperation.get(identifier);
-            messages.push({
-              severity: ValidationSeverity.Error,
-              message: `Binding identifier '${identifier}' in operation '${operationId}' is already used in path '${existing.path}' and operation '${existing.operationId}'`,
-              subject: operation,
-              validationType: ValidationType.Operation
-            });
-          } else {
-            identToPathAndOperation.set(identifier, { path: path2, operationId });
-          }
-        }
-      }
+    if (onestore == null ? void 0 : onestore.services) {
+      this.serviceOverrides = validateAndNormalizeCatalog(onestore.services);
     }
-    return messages.length > 0 ? err(messages) : ok(messages);
-  }
-}
-class ApiValidator {
-  constructor(apiValidators, typeValidator, endpointValidator) {
-    this.apiValidators = apiValidators;
-    this.typeValidator = typeValidator;
-    this.endpointValidator = endpointValidator;
-  }
-  validate(subject) {
-    const results = [
-      this.validateCollection(subject.types.values(), this.typeValidator),
-      this.validateCollection(subject.endpoints, this.endpointValidator),
-      ...this.apiValidators.map((v) => v.validate(subject))
-    ];
-    return combineValidationResults(results);
   }
-  validateCollection(items, validator) {
-    const results = [];
-    for (const item of items) {
-      results.push(validator.validate(item));
+  /**
+   * Validates all endpoints and types.  A validation error will be thrown if any are invalid.
+   *
+   * @protected
+   */
+  validate() {
+    if (!isValidAmfAPI(this, this.fileParserlogger)) {
+      throw new Error("API OneStore configuration failed validation");
     }
-    return combineValidationResults(results);
   }
 }
-function buildApiValidatorFor(api) {
-  const typeValidation = buildTypeValidator(api.types);
-  const apiValidators = [new BindingsValidation()];
-  const endpointValidation = buildEndpointValidator(api);
-  return new ApiValidator(apiValidators, typeValidation, endpointValidation);
-}
-function validateUniqueBindingIdentfiers(operations) {
-  const operationsBindings = operations.map(({ bindings }) => bindings.map(({ identifier }) => identifier)).flat();
-  const uniqueBindings = new Set(operationsBindings);
-  return operationsBindings.length === uniqueBindings.size;
-}
 async function parseAmfDocument(source, logger) {
   const parseResult = await amf.APIConfiguration.API().baseUnitClient().parse(source.toString());
   parseResult.results.forEach((result) => logResult(result, logger));
@@ -7271,13 +7309,6 @@ class AMFAPIService {
 function amfAPIService(services) {
   return new AMFAPIService(services);
 }
-function asAPIService(api) {
-  const p = Promise.resolve(api);
-  return {
-    build: () => p,
-    api
-  };
-}
 export {
   AMFAnyTypeImpl,
   AMFArrayTypeImpl,
@@ -7292,6 +7323,7 @@ export {
   AMFObjectTypeImpl,
   AMFOneOfTypeImpl,
   AMFStringTypeImpl,
+  ANONYMOUS_TYPE_NAME,
   BaseTypeRegistry,
   BindingTypesEnum,
   V1_VERSION,
@@ -7300,7 +7332,6 @@ export {
   asAPIService,
   buildApiValidatorFor,
   buildTypeValidator,
-  cacheControl,
   canonicalizeType,
   componentsOnestoreServicesSchema,
   getAmfAnnotationVersion,
@@ -7327,7 +7358,6 @@ export {
   isScalar$1 as isScalar,
   isStringType,
   isTimeType,
-  operationCacheStrategy,
   operationOnestoreServicesSchema,
   operationServiceInlineSchema,
   operationServiceRefSchema,
@@ -7336,10 +7366,8 @@ export {
   parseUrl,
   resolveDefaultServiceOverrides,
   resolveOperationServices,
-  resourceCacheControl,
   serviceVariantDescriptorSchema,
   servicesCatalogSchema,
-  typeExtensions,
   typesEqual,
   validateAndNormalizeCatalog
 };