@timardex/cluemart-server-shared 1.0.41 → 1.0.42

package/dist/{chunk-RD6GJIMM.mjs → chunk-JNKHAKC6.mjs}

@@ -397,8 +397,8 @@ var require_react_production = __commonJS({
     exports.useDeferredValue = function(value, initialValue) {
       return ReactSharedInternals.H.useDeferredValue(value, initialValue);
     };
-    exports.useEffect = function(create, deps) {
-      return ReactSharedInternals.H.useEffect(create, deps);
+    exports.useEffect = function(create2, deps) {
+      return ReactSharedInternals.H.useEffect(create2, deps);
     };
     exports.useEffectEvent = function(callback) {
       return ReactSharedInternals.H.useEffectEvent(callback);
@@ -406,17 +406,17 @@ var require_react_production = __commonJS({
     exports.useId = function() {
       return ReactSharedInternals.H.useId();
     };
-    exports.useImperativeHandle = function(ref, create, deps) {
-      return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
+    exports.useImperativeHandle = function(ref, create2, deps) {
+      return ReactSharedInternals.H.useImperativeHandle(ref, create2, deps);
     };
-    exports.useInsertionEffect = function(create, deps) {
-      return ReactSharedInternals.H.useInsertionEffect(create, deps);
+    exports.useInsertionEffect = function(create2, deps) {
+      return ReactSharedInternals.H.useInsertionEffect(create2, deps);
     };
-    exports.useLayoutEffect = function(create, deps) {
-      return ReactSharedInternals.H.useLayoutEffect(create, deps);
+    exports.useLayoutEffect = function(create2, deps) {
+      return ReactSharedInternals.H.useLayoutEffect(create2, deps);
     };
-    exports.useMemo = function(create, deps) {
-      return ReactSharedInternals.H.useMemo(create, deps);
+    exports.useMemo = function(create2, deps) {
+      return ReactSharedInternals.H.useMemo(create2, deps);
     };
     exports.useOptimistic = function(passthrough, reducer) {
       return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
@@ -1358,11 +1358,11 @@ var require_react_development = __commonJS({
       exports.useDeferredValue = function(value, initialValue) {
         return resolveDispatcher().useDeferredValue(value, initialValue);
       };
-      exports.useEffect = function(create, deps) {
-        null == create && console.warn(
+      exports.useEffect = function(create2, deps) {
+        null == create2 && console.warn(
           "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
         );
-        return resolveDispatcher().useEffect(create, deps);
+        return resolveDispatcher().useEffect(create2, deps);
       };
       exports.useEffectEvent = function(callback) {
         return resolveDispatcher().useEffectEvent(callback);
@@ -1370,23 +1370,23 @@ var require_react_development = __commonJS({
       exports.useId = function() {
         return resolveDispatcher().useId();
       };
-      exports.useImperativeHandle = function(ref, create, deps) {
-        return resolveDispatcher().useImperativeHandle(ref, create, deps);
+      exports.useImperativeHandle = function(ref, create2, deps) {
+        return resolveDispatcher().useImperativeHandle(ref, create2, deps);
       };
-      exports.useInsertionEffect = function(create, deps) {
-        null == create && console.warn(
+      exports.useInsertionEffect = function(create2, deps) {
+        null == create2 && console.warn(
           "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
         );
-        return resolveDispatcher().useInsertionEffect(create, deps);
+        return resolveDispatcher().useInsertionEffect(create2, deps);
       };
-      exports.useLayoutEffect = function(create, deps) {
-        null == create && console.warn(
+      exports.useLayoutEffect = function(create2, deps) {
+        null == create2 && console.warn(
           "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
         );
-        return resolveDispatcher().useLayoutEffect(create, deps);
+        return resolveDispatcher().useLayoutEffect(create2, deps);
       };
-      exports.useMemo = function(create, deps) {
-        return resolveDispatcher().useMemo(create, deps);
+      exports.useMemo = function(create2, deps) {
+        return resolveDispatcher().useMemo(create2, deps);
       };
       exports.useOptimistic = function(passthrough, reducer) {
         return resolveDispatcher().useOptimistic(passthrough, reducer);
@@ -4656,10 +4656,10 @@ var Condition = class _Condition {
       otherwise
     } = config;
     let check = typeof is === "function" ? is : (...values) => values.every((value) => value === is);
-    return new _Condition(refs, (values, schema12) => {
+    return new _Condition(refs, (values, schema13) => {
       var _branch;
       let branch = check(...values) ? then : otherwise;
-      return (_branch = branch == null ? void 0 : branch(schema12)) != null ? _branch : schema12;
+      return (_branch = branch == null ? void 0 : branch(schema13)) != null ? _branch : schema13;
     });
   }
   constructor(refs, builder) {
@@ -4673,13 +4673,13 @@ var Condition = class _Condition {
       // TODO: ? operator here?
       ref.getValue(options == null ? void 0 : options.value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context)
     ));
-    let schema12 = this.fn(values, base, options);
-    if (schema12 === void 0 || // @ts-ignore this can be base
-    schema12 === base) {
+    let schema13 = this.fn(values, base, options);
+    if (schema13 === void 0 || // @ts-ignore this can be base
+    schema13 === base) {
       return base;
     }
-    if (!isSchema(schema12)) throw new TypeError("conditions must return a schema object");
-    return schema12.resolve(options);
+    if (!isSchema(schema13)) throw new TypeError("conditions must return a schema object");
+    return schema13.resolve(options);
   }
 };
 var prefixes = {
@@ -4749,7 +4749,7 @@ function createValidation(config) {
     path = "",
     options,
     originalValue,
-    schema: schema12
+    schema: schema13
   }, panic, next) {
     const {
       name,
@@ -4761,8 +4761,8 @@ function createValidation(config) {
     let {
       parent,
       context,
-      abortEarly = schema12.spec.abortEarly,
-      disableStackTrace = schema12.spec.disableStackTrace
+      abortEarly = schema13.spec.abortEarly,
+      disableStackTrace = schema13.spec.disableStackTrace
     } = options;
     const resolveOptions = {
       value,
@@ -4773,9 +4773,9 @@ function createValidation(config) {
       const nextParams = resolveParams(Object.assign({
         value,
         originalValue,
-        label: schema12.spec.label,
+        label: schema13.spec.label,
         path: overrides.path || path,
-        spec: schema12.spec,
+        spec: schema13.spec,
         disableStackTrace: overrides.disableStackTrace || disableStackTrace
       }, params, overrides.params), resolveOptions);
       const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name, nextParams.disableStackTrace);
@@ -4794,7 +4794,7 @@ function createValidation(config) {
       },
       options,
       originalValue,
-      schema: schema12
+      schema: schema13
     };
     const handleResult = (validOrError) => {
       if (ValidationError.isError(validOrError)) invalid(validOrError);
@@ -4838,42 +4838,42 @@ function resolveParams(params, options) {
 function resolveMaybeRef(item, options) {
   return Reference.isRef(item) ? item.getValue(options.value, options.parent, options.context) : item;
 }
-function getIn(schema12, path, value, context = value) {
+function getIn(schema13, path, value, context = value) {
   let parent, lastPart, lastPartDebug;
   if (!path) return {
     parent,
     parentPath: path,
-    schema: schema12
+    schema: schema13
   };
   (0, import_property_expr.forEach)(path, (_part, isBracket, isArray) => {
     let part = isBracket ? _part.slice(1, _part.length - 1) : _part;
-    schema12 = schema12.resolve({
+    schema13 = schema13.resolve({
       context,
       parent,
       value
     });
-    let isTuple = schema12.type === "tuple";
+    let isTuple = schema13.type === "tuple";
     let idx = isArray ? parseInt(part, 10) : 0;
-    if (schema12.innerType || isTuple) {
+    if (schema13.innerType || isTuple) {
       if (isTuple && !isArray) throw new Error(`Yup.reach cannot implicitly index into a tuple type. the path part "${lastPartDebug}" must contain an index to the tuple element, e.g. "${lastPartDebug}[0]"`);
       if (value && idx >= value.length) {
         throw new Error(`Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path}. because there is no value at that index. `);
       }
       parent = value;
       value = value && value[idx];
-      schema12 = isTuple ? schema12.spec.types[idx] : schema12.innerType;
+      schema13 = isTuple ? schema13.spec.types[idx] : schema13.innerType;
     }
     if (!isArray) {
-      if (!schema12.fields || !schema12.fields[part]) throw new Error(`The schema does not contain the path: ${path}. (failed at: ${lastPartDebug} which is a type: "${schema12.type}")`);
+      if (!schema13.fields || !schema13.fields[part]) throw new Error(`The schema does not contain the path: ${path}. (failed at: ${lastPartDebug} which is a type: "${schema13.type}")`);
       parent = value;
       value = value && value[part];
-      schema12 = schema12.fields[part];
+      schema13 = schema13.fields[part];
     }
     lastPart = part;
     lastPartDebug = isBracket ? "[" + _part + "]" : "." + _part;
   });
   return {
-    schema: schema12,
+    schema: schema13,
     parent,
     parentPath: lastPart
   };
@@ -5073,20 +5073,20 @@ var Schema = class {
     this._mutate = before;
     return result;
   }
-  concat(schema12) {
-    if (!schema12 || schema12 === this) return this;
-    if (schema12.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema12.type}`);
+  concat(schema13) {
+    if (!schema13 || schema13 === this) return this;
+    if (schema13.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema13.type}`);
     let base = this;
-    let combined = schema12.clone();
+    let combined = schema13.clone();
     const mergedSpec = Object.assign({}, base.spec, combined.spec);
     combined.spec = mergedSpec;
     combined.internalTests = Object.assign({}, base.internalTests, combined.internalTests);
-    combined._whitelist = base._whitelist.merge(schema12._whitelist, schema12._blacklist);
-    combined._blacklist = base._blacklist.merge(schema12._blacklist, schema12._whitelist);
+    combined._whitelist = base._whitelist.merge(schema13._whitelist, schema13._blacklist);
+    combined._blacklist = base._blacklist.merge(schema13._blacklist, schema13._whitelist);
     combined.tests = base.tests;
     combined.exclusiveTests = base.exclusiveTests;
     combined.withMutation((next) => {
-      schema12.tests.forEach((fn) => {
+      schema13.tests.forEach((fn) => {
         next.test(fn.OPTIONS);
       });
     });
@@ -5102,15 +5102,15 @@ var Schema = class {
     return this._typeCheck(v);
   }
   resolve(options) {
-    let schema12 = this;
-    if (schema12.conditions.length) {
-      let conditions = schema12.conditions;
-      schema12 = schema12.clone();
-      schema12.conditions = [];
-      schema12 = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema12);
-      schema12 = schema12.resolve(options);
+    let schema13 = this;
+    if (schema13.conditions.length) {
+      let conditions = schema13.conditions;
+      schema13 = schema13.clone();
+      schema13.conditions = [];
+      schema13 = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema13);
+      schema13 = schema13.resolve(options);
     }
-    return schema12;
+    return schema13;
   }
   resolveOptions(options) {
     var _options$strict, _options$abortEarly, _options$recursive, _options$disableStack;
@@ -5266,11 +5266,11 @@ attempted value: ${formattedValue}
   }
   validate(value, options) {
     var _options$disableStack2;
-    let schema12 = this.resolve(Object.assign({}, options, {
+    let schema13 = this.resolve(Object.assign({}, options, {
       value
     }));
-    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema12.spec.disableStackTrace;
-    return new Promise((resolve, reject) => schema12._validate(value, options, (error, parsed) => {
+    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema13.spec.disableStackTrace;
+    return new Promise((resolve, reject) => schema13._validate(value, options, (error, parsed) => {
       if (ValidationError.isError(error)) error.value = parsed;
       reject(error);
     }, (errors, validated) => {
@@ -5280,12 +5280,12 @@ attempted value: ${formattedValue}
   }
   validateSync(value, options) {
     var _options$disableStack3;
-    let schema12 = this.resolve(Object.assign({}, options, {
+    let schema13 = this.resolve(Object.assign({}, options, {
       value
     }));
     let result;
-    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema12.spec.disableStackTrace;
-    schema12._validate(value, Object.assign({}, options, {
+    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema13.spec.disableStackTrace;
+    schema13._validate(value, Object.assign({}, options, {
       sync: true
     }), (error, parsed) => {
       if (ValidationError.isError(error)) error.value = parsed;
@@ -5319,8 +5319,8 @@ attempted value: ${formattedValue}
     return typeof defaultValue === "function" ? defaultValue.call(this, options) : clone(defaultValue);
   }
   getDefault(options) {
-    let schema12 = this.resolve(options || {});
-    return schema12._getDefault(options);
+    let schema13 = this.resolve(options || {});
+    return schema13._getDefault(options);
   }
   default(def) {
     if (arguments.length === 0) {
@@ -5553,13 +5553,13 @@ attempted value: ${formattedValue}
     return description;
   }
   get ["~standard"]() {
-    const schema12 = this;
+    const schema13 = this;
     const standard = {
       version: 1,
       vendor: "yup",
       async validate(value) {
         try {
-          const result = await schema12.validate(value, {
+          const result = await schema13.validate(value, {
             abortEarly: false
           });
           return {
@@ -5583,9 +5583,9 @@ for (const method of ["validate", "validateSync"]) Schema.prototype[`${method}At
   const {
     parent,
     parentPath,
-    schema: schema12
+    schema: schema13
   } = getIn(this, path, value, options.context);
-  return schema12[method](parent && parent[parentPath], Object.assign({}, options, {
+  return schema13[method](parent && parent[parentPath], Object.assign({}, options, {
     parent,
     path
   }));
@@ -5759,7 +5759,7 @@ var StringSchema = class extends Schema {
     });
   }
   required(message) {
-    return super.required(message).withMutation((schema12) => schema12.test({
+    return super.required(message).withMutation((schema13) => schema13.test({
       message: message || mixed.required,
       name: "required",
       skipAbsent: true,
@@ -5767,9 +5767,9 @@ var StringSchema = class extends Schema {
     }));
   }
   notRequired() {
-    return super.notRequired().withMutation((schema12) => {
-      schema12.tests = schema12.tests.filter((t) => t.OPTIONS.name !== "required");
-      return schema12;
+    return super.notRequired().withMutation((schema13) => {
+      schema13.tests = schema13.tests.filter((t) => t.OPTIONS.name !== "required");
+      return schema13;
     });
   }
   length(length, message = string.length) {
@@ -6147,7 +6147,7 @@ function sortByKeyOrder(keys) {
     return findIndex(keys, a) - findIndex(keys, b);
   };
 }
-var parseJson = (value, _, schema12) => {
+var parseJson = (value, _, schema13) => {
   if (typeof value !== "string") {
     return value;
   }
@@ -6156,30 +6156,30 @@ var parseJson = (value, _, schema12) => {
     parsed = JSON.parse(value);
   } catch (err) {
   }
-  return schema12.isType(parsed) ? parsed : value;
+  return schema13.isType(parsed) ? parsed : value;
 };
-function deepPartial(schema12) {
-  if ("fields" in schema12) {
+function deepPartial(schema13) {
+  if ("fields" in schema13) {
     const partial = {};
-    for (const [key, fieldSchema] of Object.entries(schema12.fields)) {
+    for (const [key, fieldSchema] of Object.entries(schema13.fields)) {
       partial[key] = deepPartial(fieldSchema);
     }
-    return schema12.setFields(partial);
+    return schema13.setFields(partial);
   }
-  if (schema12.type === "array") {
-    const nextArray = schema12.optional();
+  if (schema13.type === "array") {
+    const nextArray = schema13.optional();
     if (nextArray.innerType) nextArray.innerType = deepPartial(nextArray.innerType);
     return nextArray;
   }
-  if (schema12.type === "tuple") {
-    return schema12.optional().clone({
-      types: schema12.spec.types.map(deepPartial)
+  if (schema13.type === "tuple") {
+    return schema13.optional().clone({
+      types: schema13.spec.types.map(deepPartial)
     });
   }
-  if ("optional" in schema12) {
-    return schema12.optional();
+  if ("optional" in schema13) {
+    return schema13.optional();
   }
-  return schema12;
+  return schema13;
 }
 var deepHas = (obj, p) => {
   const path = [...(0, import_property_expr.normalizePath)(p)];
@@ -6310,8 +6310,8 @@ var ObjectSchema = class extends Schema {
     next._sortErrors = this._sortErrors;
     return next;
   }
-  concat(schema12) {
-    let next = super.concat(schema12);
+  concat(schema13) {
+    let next = super.concat(schema13);
     let nextFields = next.fields;
     for (let [field, schemaOrRef] of Object.entries(this.fields)) {
       const target = nextFields[field];
@@ -6319,7 +6319,7 @@ var ObjectSchema = class extends Schema {
     }
     return next.withMutation((s2) => (
       // XXX: excludes here is wrong
-      s2.setFields(nextFields, [...this._excludedEdges, ...schema12._excludedEdges])
+      s2.setFields(nextFields, [...this._excludedEdges, ...schema13._excludedEdges])
     ));
   }
   _getDefault(options) {
@@ -6364,8 +6364,8 @@ var ObjectSchema = class extends Schema {
   }
   partial() {
     const partial = {};
-    for (const [key, schema12] of Object.entries(this.fields)) {
-      partial[key] = "optional" in schema12 && schema12.optional instanceof Function ? schema12.optional() : schema12;
+    for (const [key, schema13] of Object.entries(this.fields)) {
+      partial[key] = "optional" in schema13 && schema13.optional instanceof Function ? schema13.optional() : schema13;
     }
     return this.setFields(partial);
   }
@@ -6567,22 +6567,22 @@ var ArraySchema = class extends Schema {
   json() {
     return this.transform(parseJson);
   }
-  concat(schema12) {
-    let next = super.concat(schema12);
+  concat(schema13) {
+    let next = super.concat(schema13);
     next.innerType = this.innerType;
-    if (schema12.innerType)
+    if (schema13.innerType)
       next.innerType = next.innerType ? (
         // @ts-expect-error Lazy doesn't have concat and will break
-        next.innerType.concat(schema12.innerType)
-      ) : schema12.innerType;
+        next.innerType.concat(schema13.innerType)
+      ) : schema13.innerType;
     return next;
   }
-  of(schema12) {
+  of(schema13) {
     let next = this.clone();
-    if (!isSchema(schema12)) throw new TypeError("`array.of()` sub-schema must be a valid yup schema not: " + printValue(schema12));
-    next.innerType = schema12;
+    if (!isSchema(schema13)) throw new TypeError("`array.of()` sub-schema must be a valid yup schema not: " + printValue(schema13));
+    next.innerType = schema13;
     next.spec = Object.assign({}, next.spec, {
-      types: schema12
+      types: schema13
     });
     return next;
   }
@@ -6730,7 +6730,7 @@ var TupleSchema = class extends Schema {
   describe(options) {
     const next = (options ? this.resolve(options) : this).clone();
     const base = super.describe(options);
-    base.innerType = next.spec.types.map((schema12, index) => {
+    base.innerType = next.spec.types.map((schema13, index) => {
       var _innerOptions;
       let innerOptions = options;
       if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
@@ -6739,12 +6739,137 @@ var TupleSchema = class extends Schema {
           value: innerOptions.value[index]
         });
       }
-      return schema12.describe(innerOptions);
+      return schema13.describe(innerOptions);
     });
     return base;
   }
 };
 create$1.prototype = TupleSchema.prototype;
+function create(builder) {
+  return new Lazy(builder);
+}
+function catchValidationError(fn) {
+  try {
+    return fn();
+  } catch (err) {
+    if (ValidationError.isError(err)) return Promise.reject(err);
+    throw err;
+  }
+}
+var Lazy = class _Lazy {
+  constructor(builder) {
+    this.type = "lazy";
+    this.__isYupSchema__ = true;
+    this.spec = void 0;
+    this._resolve = (value, options = {}) => {
+      let schema13 = this.builder(value, options);
+      if (!isSchema(schema13)) throw new TypeError("lazy() functions must return a valid schema");
+      if (this.spec.optional) schema13 = schema13.optional();
+      return schema13.resolve(options);
+    };
+    this.builder = builder;
+    this.spec = {
+      meta: void 0,
+      optional: false
+    };
+  }
+  clone(spec) {
+    const next = new _Lazy(this.builder);
+    next.spec = Object.assign({}, this.spec, spec);
+    return next;
+  }
+  optionality(optional) {
+    const next = this.clone({
+      optional
+    });
+    return next;
+  }
+  optional() {
+    return this.optionality(true);
+  }
+  resolve(options) {
+    return this._resolve(options.value, options);
+  }
+  cast(value, options) {
+    return this._resolve(value, options).cast(value, options);
+  }
+  asNestedTest(config) {
+    let {
+      key,
+      index,
+      parent,
+      options
+    } = config;
+    let value = parent[index != null ? index : key];
+    return this._resolve(value, Object.assign({}, options, {
+      value,
+      parent
+    })).asNestedTest(config);
+  }
+  validate(value, options) {
+    return catchValidationError(() => this._resolve(value, options).validate(value, options));
+  }
+  validateSync(value, options) {
+    return this._resolve(value, options).validateSync(value, options);
+  }
+  validateAt(path, value, options) {
+    return catchValidationError(() => this._resolve(value, options).validateAt(path, value, options));
+  }
+  validateSyncAt(path, value, options) {
+    return this._resolve(value, options).validateSyncAt(path, value, options);
+  }
+  isValid(value, options) {
+    try {
+      return this._resolve(value, options).isValid(value, options);
+    } catch (err) {
+      if (ValidationError.isError(err)) {
+        return Promise.resolve(false);
+      }
+      throw err;
+    }
+  }
+  isValidSync(value, options) {
+    return this._resolve(value, options).isValidSync(value, options);
+  }
+  describe(options) {
+    return options ? this.resolve(options).describe(options) : {
+      type: "lazy",
+      meta: this.spec.meta,
+      label: void 0
+    };
+  }
+  meta(...args) {
+    if (args.length === 0) return this.spec.meta;
+    let next = this.clone();
+    next.spec.meta = Object.assign(next.spec.meta || {}, args[0]);
+    return next;
+  }
+  get ["~standard"]() {
+    const schema13 = this;
+    const standard = {
+      version: 1,
+      vendor: "yup",
+      async validate(value) {
+        try {
+          const result = await schema13.validate(value, {
+            abortEarly: false
+          });
+          return {
+            value: result
+          };
+        } catch (err) {
+          if (ValidationError.isError(err)) {
+            return {
+              issues: issuesFromValidationError(err)
+            };
+          }
+          throw err;
+        }
+      }
+    };
+    return standard;
+  }
+};
 
 // node_modules/@timardex/cluemart-shared/dist/index.mjs
 var React2 = __toESM(require_react(), 1);
@@ -6755,6 +6880,7 @@ var import_react = __toESM(require_react(), 1);
 var import_react2 = __toESM(require_react(), 1);
 var import_react3 = __toESM(require_react(), 1);
 var React9 = __toESM(require_react(), 1);
+var import_react4 = __toESM(require_react(), 1);
 var EnumInviteStatus = /* @__PURE__ */ ((EnumInviteStatus22) => {
   EnumInviteStatus22["ACCEPTED"] = "Accepted";
   EnumInviteStatus22["COMPLETED"] = "Completed";
@@ -9726,6 +9852,91 @@ var DELETE_PARTNER_MUTATION = gql`
     deletePartner(_id: $_id)
   }
 `;
+var POST_CONTENT_DATA_FIELDS_FRAGMENT = gql`
+  fragment PostContentDataFields on PostContentData {
+    cover {
+      ...ResourceImageFields
+    }
+    textarea {
+      title
+      data
+    }
+    images {
+      ...ResourceImageFields
+    }
+    video {
+      source
+      title
+    }
+    list {
+      title
+      items
+    }
+  }
+  ${RESOURCE_IMAGE_FIELDS_FRAGMENT}
+`;
+var POST_CONTENT_FIELDS_FRAGMENT = gql`
+  fragment PostContentFields on PostContentType {
+    _id
+    contentData {
+      ...PostContentDataFields
+    }
+    contentOrder
+    contentType
+  }
+  ${POST_CONTENT_DATA_FIELDS_FRAGMENT}
+`;
+var POST_FIELDS_FRAGMENT = gql`
+  fragment PostFields on PostType {
+    _id
+    content {
+      ...PostContentFields
+    }
+    postType
+    tags
+    title
+    createdAt
+    updatedAt
+  }
+  ${POST_CONTENT_FIELDS_FRAGMENT}
+`;
+var GET_POSTS = gql`
+  query getPosts {
+    posts {
+      ...PostFields
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+var GET_POST = gql`
+  query getPost($postId: ID!) {
+    post(postId: $postId) {
+      ...PostFields
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+var CREATE_POST_MUTATION = gql`
+  mutation createPost($input: PostInputType!) {
+    createPost(input: $input) {
+      ...PostFields
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+var UPDATE_POST_MUTATION = gql`
+  mutation updatePost($_id: ID!, $input: PostInputType!) {
+    updatePost(_id: $_id, input: $input) {
+      ...PostFields
+    }
+  }
+  ${POST_FIELDS_FRAGMENT}
+`;
+var DELETE_POST_MUTATION = gql`
+  mutation deletePost($_id: ID!) {
+    deletePost(_id: $_id)
+  }
+`;
 var nzBankAccountRegex = /^\d{2}-\d{4}-\d{7}-\d{2}$/;
 var nzbnRegex = /^94\d{11}$/;
 var normalizedUrlTransform = () => create$6().trim().transform(
@@ -9879,7 +10090,7 @@ var socialMediaSchema = create$3({
     is: (name) => !!name,
     // If name has a value
     then: () => normalizedUrlTransform().required("Link is required when name is set").url("Link must be a valid URL").label("Social Media Link"),
-    otherwise: (schema12) => schema12.notRequired()
+    otherwise: (schema13) => schema13.notRequired()
   })
 });
 var globalResourceSchema = create$3().shape({
@@ -9952,21 +10163,21 @@ var paymentInfoSchema = create$3({
   paymentMethod: create$8().oneOf(Object.values(EnumPaymentMethod)).required("Please select a Payment method"),
   accountHolderName: create$6().when("paymentMethod", {
     is: "bank_transfer",
-    then: (schema12) => schema12.required("Account holder name is required for bank transfer").trim(),
-    otherwise: (schema12) => schema12.notRequired()
+    then: (schema13) => schema13.required("Account holder name is required for bank transfer").trim(),
+    otherwise: (schema13) => schema13.notRequired()
   }),
   accountNumber: create$6().when("paymentMethod", {
     is: "bank_transfer",
-    then: (schema12) => schema12.required("Account number is required for bank transfer").matches(
+    then: (schema13) => schema13.required("Account number is required for bank transfer").matches(
       nzBankAccountRegex,
       "Account number must be in format: XX-XXXX-XXXXXXX-XX"
     ).trim(),
-    otherwise: (schema12) => schema12.notRequired()
+    otherwise: (schema13) => schema13.notRequired()
   }),
   link: create$6().when("paymentMethod", {
     is: (val) => val !== "bank_transfer",
     then: () => normalizedUrlTransform().url("Link must be a valid URL").required("Link is required for PayPal/Stripe"),
-    otherwise: (schema12) => schema12.notRequired()
+    otherwise: (schema13) => schema13.notRequired()
   })
 });
 var eventInfoSchema = create$3().shape({
@@ -10054,8 +10265,8 @@ var userSchema = create$3().shape({
   confirmPassword: create$6().nullable().trim().label("Confirm Password").when("password", {
     is: (val) => !!val,
     // only necessary if password typed
-    then: (schema12) => schema12.required("Confirm Password is required").oneOf([create$9("password")], "Passwords must match"),
-    otherwise: (schema12) => schema12.notRequired()
+    then: (schema13) => schema13.required("Confirm Password is required").oneOf([create$9("password")], "Passwords must match"),
+    otherwise: (schema13) => schema13.notRequired()
   }),
   role: create$8().oneOf(Object.values(EnumUserRole)).required("Role is required")
 });
@@ -10168,8 +10379,8 @@ var testerSchema = create$3().shape({
   email: emailRequiredSchema,
   event: create$3().when("resourceType", {
     is: (resourceType) => resourceType === "event",
-    otherwise: (schema12) => schema12.nullable().optional(),
-    then: (schema12) => schema12.required("Event information is required").shape(testerEventSchema.fields)
+    otherwise: (schema13) => schema13.nullable().optional(),
+    then: (schema13) => schema13.required("Event information is required").shape(testerEventSchema.fields)
   }),
   firstName: create$6().required("First name is required"),
   lastName: create$6().required("Last name is required"),
@@ -10187,8 +10398,8 @@ var testerSchema = create$3().shape({
   ).required("Resource Type is required"),
   vendor: create$3().when("resourceType", {
     is: (resourceType) => resourceType === "vendor",
-    otherwise: (schema12) => schema12.nullable().optional(),
-    then: (schema12) => schema12.required("Vendor information is required").shape(testerVendorSchema.fields)
+    otherwise: (schema13) => schema13.nullable().optional(),
+    then: (schema13) => schema13.required("Vendor information is required").shape(testerVendorSchema.fields)
   })
 });
 var EnumAdShowOn = /* @__PURE__ */ ((EnumAdShowOn2) => {
@@ -10226,7 +10437,7 @@ var adSchema = create$3().shape({
     return endDate > now;
   }).when("start", {
     is: (val) => val && val.length > 0,
-    then: (schema12) => schema12.test(
+    then: (schema13) => schema13.test(
       "is-after-start",
       "End date must be after start date",
       function(value) {
@@ -10264,6 +10475,80 @@ var partnerSchema = globalResourceSchema.shape({
   nzbn: create$6().required("NZBN is required").matches(nzbnRegex, "NZBN must be 13 digits and start with 94"),
   partnerType: create$8().oneOf(Object.values(EnumPartnerType)).required("Please select a Partner type")
 });
+var EnumPostType = /* @__PURE__ */ ((EnumPostType2) => {
+  EnumPostType2["DAILY_MEETS"] = "daily_meets";
+  EnumPostType2["DAILY_TIPS"] = "daily_tips";
+  EnumPostType2["DAILY_POLL"] = "daily_poll";
+  return EnumPostType2;
+})(EnumPostType || {});
+var EnumPostContentType = /* @__PURE__ */ ((EnumPostContentType2) => {
+  EnumPostContentType2["COVER"] = "cover";
+  EnumPostContentType2["IMAGE"] = "image";
+  EnumPostContentType2["LIST"] = "list";
+  EnumPostContentType2["TEXTAREA"] = "textarea";
+  EnumPostContentType2["VIDEO"] = "video";
+  return EnumPostContentType2;
+})(EnumPostContentType || {});
+var coverContentSchema = create$3({
+  cover: create$3({
+    source: create$6().required("Cover source is required"),
+    title: create$6().required("Cover title is required")
+  }).required()
+});
+var textareaContentSchema = create$3({
+  textarea: create$3({
+    data: create$6().required("Textarea content is required"),
+    title: create$6().optional()
+  }).required()
+});
+var imagesContentSchema = create$3({
+  images: create$2().of(
+    create$3({
+      source: create$6().required("Image source is required"),
+      title: create$6().required("Image title is required")
+    })
+  ).nullable()
+});
+var videoContentSchema = create$3({
+  video: create$3({
+    source: create$6().required("Video source is required"),
+    title: create$6().optional()
+  }).required()
+});
+var listContentSchema = create$3({
+  list: create$3({
+    items: create$2().of(create$6().required()).min(1, "List must contain at least one item").required(),
+    title: create$6().optional()
+  }).required()
+});
+var contentDataSchema = create((_, options) => {
+  const contentType = options.parent?.contentType;
+  switch (contentType) {
+    case "cover":
+      return coverContentSchema;
+    case "textarea":
+      return textareaContentSchema;
+    case "image":
+      return imagesContentSchema;
+    case "video":
+      return videoContentSchema;
+    case "list":
+      return listContentSchema;
+    default:
+      return create$8().required();
+  }
+});
+var postContentSchema = create$3().shape({
+  contentData: contentDataSchema.required(),
+  contentOrder: create$5().min(0).required(),
+  contentType: create$8().oneOf(Object.values(EnumPostContentType)).required()
+});
+var postSchema = create$3().shape({
+  content: create$2().of(postContentSchema).required(),
+  postType: create$8().oneOf(Object.values(EnumPostType)).required(),
+  tags: create$2().of(create$6()).nullable().optional(),
+  title: create$6().required()
+});
 var defaultLocation = {
   city: "",
   coordinates: [0, 0],
@@ -11428,6 +11713,38 @@ schema11.index({ location: "2dsphere" });
 schema11.index({ "associates.email": 1 });
 var PartnerModel = mongoose15.models.Partner || mongoose15.model("Partner", schema11);
 
+// src/mongoose/Post.ts
+import mongoose16, { Schema as Schema2 } from "mongoose";
+var MongooseSchema16 = mongoose16.Schema;
+var contentSchema = new MongooseSchema16(
+  {
+    contentData: Schema2.Types.Mixed,
+    contentOrder: { required: true, type: Number },
+    contentType: {
+      enum: Object.values(EnumPostContentType),
+      required: true,
+      type: String
+    }
+  },
+  { _id: false }
+);
+var schema12 = new MongooseSchema16(
+  {
+    content: { required: true, type: contentSchema },
+    postType: {
+      enum: Object.values(EnumPostType),
+      required: true,
+      type: String
+    },
+    tags: { default: [], required: false, type: [String] },
+    title: { required: true, type: String }
+  },
+  { timestamps: true }
+);
+schema12.index({ title: 1 });
+schema12.index({ tags: 1 });
+var PostModel = mongoose16.models.Post || mongoose16.model("Post", schema12);
+
 export {
   EnumAdStatus,
   StallTypeSchema,
@@ -11457,7 +11774,8 @@ export {
   VendorInfoModel,
   locationsSchema,
   EventModel,
-  PartnerModel
+  PartnerModel,
+  PostModel
 };
 /*! Bundled license information:
 
@@ -11483,4 +11801,4 @@ react/cjs/react.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-RD6GJIMM.mjs.map
+//# sourceMappingURL=chunk-JNKHAKC6.mjs.map