@kortex-ai/hub-client 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1125 @@
+import z, { z as z$1 } from 'zod';
+import * as zCore from 'zod/v4/core';
+import * as z2 from 'zod/v4';
+
+// ../src/shared/errors/neverthrow.ts
+function ok(data) {
+  return { data, error: null };
+}
+function err(error) {
+  return { data: null, error };
+}
+
+// ../src/shared/services/http/util.ts
+function prepareFetchBodyAndHeaders(body, headers) {
+  const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+  const isBlob = typeof Blob !== "undefined" && body instanceof Blob;
+  const isArrayBuffer = typeof ArrayBuffer !== "undefined" && (body instanceof ArrayBuffer || ArrayBuffer.isView && ArrayBuffer.isView(body));
+  const shouldStringify = !isFormData && !isBlob && !isArrayBuffer && typeof body === "object";
+  const headersObj = { ...headers ?? {} };
+  if (!headersObj["Content-Type"]) {
+    if (shouldStringify) {
+      headersObj["Content-Type"] = "application/json";
+    } else if (isBlob) {
+      const blobType = body.type;
+      if (blobType) headersObj["Content-Type"] = blobType;
+    }
+  }
+  const finalBody = isFormData || isBlob || isArrayBuffer ? body : shouldStringify ? JSON.stringify(body) : body;
+  return {
+    body: finalBody,
+    headers: Object.keys(headersObj).length ? headersObj : void 0
+  };
+}
+
+// ../src/shared/services/http/http.service.ts
+var HttpService = class {
+  static async get(url, params, headers, responseType) {
+    try {
+      const queryParams = new URLSearchParams(params);
+      const apiUrl = queryParams.toString() ? `${url}?${queryParams.toString()}` : url;
+      const response = await fetch(apiUrl, {
+        method: "GET",
+        headers
+      });
+      if (!response.ok) {
+        const message = await response.text();
+        return err({ message });
+      }
+      if (responseType === "blob") {
+        return ok(await response.blob());
+      }
+      if (responseType === "text") {
+        return ok(await response.text());
+      }
+      return ok(await response.json());
+    } catch (error) {
+      return err({ message: error.message });
+    }
+  }
+  static async post(url, body, headers, credentials) {
+    try {
+      const { body: finalBody, headers: finalHeaders } = prepareFetchBodyAndHeaders(body, headers);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: finalHeaders,
+        body: finalBody,
+        credentials
+      });
+      if (!response.ok) {
+        const message = await response.text();
+        return err({ message });
+      }
+      return ok(await response.json());
+    } catch (error) {
+      return err({ message: error.message });
+    }
+  }
+  static async put(url, body, headers) {
+    try {
+      const { body: finalBody, headers: finalHeaders } = prepareFetchBodyAndHeaders(body, headers);
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: finalHeaders,
+        body: finalBody
+      });
+      if (!response.ok) {
+        const message = await response.text();
+        return err({ message });
+      }
+      return ok(await response.json());
+    } catch (error) {
+      return err({ message: error.message });
+    }
+  }
+  static async delete(url, params, headers) {
+    try {
+      const queryParams = new URLSearchParams(params);
+      const apiUrl = queryParams.toString() ? `${url}?${queryParams.toString()}` : url;
+      const response = await fetch(apiUrl, {
+        method: "DELETE",
+        headers
+      });
+      if (!response.ok) {
+        const message = await response.text();
+        return err({ message });
+      }
+      return ok(await response.json());
+    } catch (error) {
+      return err({ message: error.message });
+    }
+  }
+};
+var TextContent = z.object({
+  text: z.string()
+});
+z.object({
+  id: z.string(),
+  mime_type: z.string(),
+  sha256: z.string(),
+  caption: z.string().nullable()
+});
+z.object({
+  id: z.string(),
+  mime_type: z.string(),
+  sha256: z.string(),
+  caption: z.string().nullable()
+});
+z.object({
+  id: z.string(),
+  mime_type: z.string(),
+  sha256: z.string(),
+  animated: z.boolean().nullable()
+});
+z.object({
+  id: z.string(),
+  mime_type: z.string(),
+  sha256: z.string(),
+  voice: z.boolean()
+});
+z.object({
+  id: z.string(),
+  mime_type: z.string(),
+  sha256: z.string(),
+  filename: z.string(),
+  caption: z.string().nullable()
+});
+z.object({
+  latitude: z.number(),
+  longitude: z.number(),
+  name: z.string().nullable(),
+  address: z.string().nullable(),
+  url: z.string().nullable()
+});
+z.object({
+  name: z.object({
+    formatted_name: z.string().nullable(),
+    first_name: z.string().nullable(),
+    last_name: z.string().nullable(),
+    middle_name: z.string().nullable(),
+    suffix: z.string().nullable(),
+    prefix: z.string().nullable()
+  }),
+  phones: z.array(
+    z.object({
+      phone: z.string().nullable(),
+      type: z.string().nullable(),
+      wa_id: z.string().nullable()
+    })
+  ).nullable()
+});
+z.object({
+  emoji: z.string().nullable()
+});
+var TemplateContent = z.object({
+  name: z.string(),
+  language: z.string(),
+  renderedText: z.string(),
+  // The rendered template text with variables filled in.
+  header_variable: z.string().optional(),
+  // Single variable for header component (only {{1}} is supported). Not saved in DB.
+  body_variables: z.array(z.string()).optional(),
+  // Variables for the body component {{1}}, {{2}}, etc. Not saved in DB.
+  button_variables: z.array(z.string()).max(2).optional()
+  // Variables for URL buttons in order. Each URL button can have max 1 variable. Not saved in DB.
+});
+
+// ../node_modules/.pnpm/convex@1.31.6_react@19.2.0/node_modules/convex/dist/esm/values/base64.js
+var lookup = [];
+var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+}
+var i;
+var len;
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  var tmp;
+  var len = uint8.length;
+  var extraBytes = len % 3;
+  var parts = [];
+  var maxChunkLength = 16383;
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(
+      encodeChunk(
+        uint8,
+        i,
+        i + maxChunkLength > len2 ? len2 : i + maxChunkLength
+      )
+    );
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(
+      lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+    );
+  }
+  return parts.join("");
+}
+
+// ../node_modules/.pnpm/convex@1.31.6_react@19.2.0/node_modules/convex/dist/esm/common/index.js
+function isSimpleObject(value) {
+  const isObject = typeof value === "object";
+  const prototype = Object.getPrototypeOf(value);
+  const isSimple = prototype === null || prototype === Object.prototype || // Objects generated from other contexts (e.g. across Node.js `vm` modules) will not satisfy the previous
+  // conditions but are still simple objects.
+  prototype?.constructor?.name === "Object";
+  return isObject && isSimple;
+}
+
+// ../node_modules/.pnpm/convex@1.31.6_react@19.2.0/node_modules/convex/dist/esm/values/value.js
+var LITTLE_ENDIAN = true;
+var MIN_INT64 = BigInt("-9223372036854775808");
+var MAX_INT64 = BigInt("9223372036854775807");
+var ZERO = BigInt("0");
+var EIGHT = BigInt("8");
+BigInt("256");
+function isSpecial(n) {
+  return Number.isNaN(n) || !Number.isFinite(n) || Object.is(n, -0);
+}
+function slowBigIntToBase64(value) {
+  if (value < ZERO) {
+    value -= MIN_INT64 + MIN_INT64;
+  }
+  let hex = value.toString(16);
+  if (hex.length % 2 === 1) hex = "0" + hex;
+  const bytes2 = new Uint8Array(new ArrayBuffer(8));
+  let i = 0;
+  for (const hexByte of hex.match(/.{2}/g).reverse()) {
+    bytes2.set([parseInt(hexByte, 16)], i++);
+    value >>= EIGHT;
+  }
+  return fromByteArray(bytes2);
+}
+function modernBigIntToBase64(value) {
+  if (value < MIN_INT64 || MAX_INT64 < value) {
+    throw new Error(
+      `BigInt ${value} does not fit into a 64-bit signed integer.`
+    );
+  }
+  const buffer = new ArrayBuffer(8);
+  new DataView(buffer).setBigInt64(0, value, true);
+  return fromByteArray(new Uint8Array(buffer));
+}
+var bigIntToBase64 = DataView.prototype.setBigInt64 ? modernBigIntToBase64 : slowBigIntToBase64;
+var MAX_IDENTIFIER_LEN = 1024;
+function validateObjectField(k) {
+  if (k.length > MAX_IDENTIFIER_LEN) {
+    throw new Error(
+      `Field name ${k} exceeds maximum field name length ${MAX_IDENTIFIER_LEN}.`
+    );
+  }
+  if (k.startsWith("$")) {
+    throw new Error(`Field name ${k} starts with a '$', which is reserved.`);
+  }
+  for (let i = 0; i < k.length; i += 1) {
+    const charCode = k.charCodeAt(i);
+    if (charCode < 32 || charCode >= 127) {
+      throw new Error(
+        `Field name ${k} has invalid character '${k[i]}': Field names can only contain non-control ASCII characters`
+      );
+    }
+  }
+}
+var MAX_VALUE_FOR_ERROR_LEN = 16384;
+function stringifyValueForError(value) {
+  const str = JSON.stringify(value, (_key, value2) => {
+    if (value2 === void 0) {
+      return "undefined";
+    }
+    if (typeof value2 === "bigint") {
+      return `${value2.toString()}n`;
+    }
+    return value2;
+  });
+  if (str.length > MAX_VALUE_FOR_ERROR_LEN) {
+    const rest = "[...truncated]";
+    let truncateAt = MAX_VALUE_FOR_ERROR_LEN - rest.length;
+    const codePoint = str.codePointAt(truncateAt - 1);
+    if (codePoint !== void 0 && codePoint > 65535) {
+      truncateAt -= 1;
+    }
+    return str.substring(0, truncateAt) + rest;
+  }
+  return str;
+}
+function convexToJsonInternal(value, originalValue, context, includeTopLevelUndefined) {
+  if (value === void 0) {
+    const contextText = context && ` (present at path ${context} in original object ${stringifyValueForError(
+      originalValue
+    )})`;
+    throw new Error(
+      `undefined is not a valid Convex value${contextText}. To learn about Convex's supported types, see https://docs.convex.dev/using/types.`
+    );
+  }
+  if (value === null) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    if (value < MIN_INT64 || MAX_INT64 < value) {
+      throw new Error(
+        `BigInt ${value} does not fit into a 64-bit signed integer.`
+      );
+    }
+    return { $integer: bigIntToBase64(value) };
+  }
+  if (typeof value === "number") {
+    if (isSpecial(value)) {
+      const buffer = new ArrayBuffer(8);
+      new DataView(buffer).setFloat64(0, value, LITTLE_ENDIAN);
+      return { $float: fromByteArray(new Uint8Array(buffer)) };
+    } else {
+      return value;
+    }
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return { $bytes: fromByteArray(new Uint8Array(value)) };
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (value2, i) => convexToJsonInternal(value2, originalValue, context + `[${i}]`)
+    );
+  }
+  if (value instanceof Set) {
+    throw new Error(
+      errorMessageForUnsupportedType(context, "Set", [...value], originalValue)
+    );
+  }
+  if (value instanceof Map) {
+    throw new Error(
+      errorMessageForUnsupportedType(context, "Map", [...value], originalValue)
+    );
+  }
+  if (!isSimpleObject(value)) {
+    const theType = value?.constructor?.name;
+    const typeName = theType ? `${theType} ` : "";
+    throw new Error(
+      errorMessageForUnsupportedType(context, typeName, value, originalValue)
+    );
+  }
+  const out = {};
+  const entries = Object.entries(value);
+  entries.sort(([k1, _v1], [k2, _v2]) => k1 === k2 ? 0 : k1 < k2 ? -1 : 1);
+  for (const [k, v2] of entries) {
+    if (v2 !== void 0) {
+      validateObjectField(k);
+      out[k] = convexToJsonInternal(v2, originalValue, context + `.${k}`);
+    }
+  }
+  return out;
+}
+function errorMessageForUnsupportedType(context, typeName, value, originalValue) {
+  if (context) {
+    return `${typeName}${stringifyValueForError(
+      value
+    )} is not a supported Convex type (present at path ${context} in original object ${stringifyValueForError(
+      originalValue
+    )}). To learn about Convex's supported types, see https://docs.convex.dev/using/types.`;
+  } else {
+    return `${typeName}${stringifyValueForError(
+      value
+    )} is not a supported Convex type.`;
+  }
+}
+function convexToJson(value) {
+  return convexToJsonInternal(value, value, "");
+}
+
+// ../node_modules/.pnpm/convex@1.31.6_react@19.2.0/node_modules/convex/dist/esm/values/validators.js
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var UNDEFINED_VALIDATOR_ERROR_URL = "https://docs.convex.dev/error#undefined-validator";
+function throwUndefinedValidatorError(context, fieldName) {
+  const fieldInfo = fieldName !== void 0 ? ` for field "${fieldName}"` : "";
+  throw new Error(
+    `A validator is undefined${fieldInfo} in ${context}. This is often caused by circular imports. See ${UNDEFINED_VALIDATOR_ERROR_URL} for details.`
+  );
+}
+var BaseValidator = class {
+  constructor({ isOptional }) {
+    __publicField(this, "type");
+    __publicField(this, "fieldPaths");
+    __publicField(this, "isOptional");
+    __publicField(this, "isConvexValidator");
+    this.isOptional = isOptional;
+    this.isConvexValidator = true;
+  }
+};
+var VId = class _VId extends BaseValidator {
+  /**
+   * Usually you'd use `v.id(tableName)` instead.
+   */
+  constructor({
+    isOptional,
+    tableName
+  }) {
+    super({ isOptional });
+    __publicField(this, "tableName");
+    __publicField(this, "kind", "id");
+    if (typeof tableName !== "string") {
+      throw new Error("v.id(tableName) requires a string");
+    }
+    this.tableName = tableName;
+  }
+  /** @internal */
+  get json() {
+    return { type: "id", tableName: this.tableName };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VId({
+      isOptional: "optional",
+      tableName: this.tableName
+    });
+  }
+};
+var VFloat64 = class _VFloat64 extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "float64");
+  }
+  /** @internal */
+  get json() {
+    return { type: "number" };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VFloat64({
+      isOptional: "optional"
+    });
+  }
+};
+var VInt64 = class _VInt64 extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "int64");
+  }
+  /** @internal */
+  get json() {
+    return { type: "bigint" };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VInt64({ isOptional: "optional" });
+  }
+};
+var VBoolean = class _VBoolean extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "boolean");
+  }
+  /** @internal */
+  get json() {
+    return { type: this.kind };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VBoolean({
+      isOptional: "optional"
+    });
+  }
+};
+var VBytes = class _VBytes extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "bytes");
+  }
+  /** @internal */
+  get json() {
+    return { type: this.kind };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VBytes({ isOptional: "optional" });
+  }
+};
+var VString = class _VString extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "string");
+  }
+  /** @internal */
+  get json() {
+    return { type: this.kind };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VString({
+      isOptional: "optional"
+    });
+  }
+};
+var VNull = class _VNull extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "null");
+  }
+  /** @internal */
+  get json() {
+    return { type: this.kind };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VNull({ isOptional: "optional" });
+  }
+};
+var VAny = class _VAny extends BaseValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "kind", "any");
+  }
+  /** @internal */
+  get json() {
+    return {
+      type: this.kind
+    };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VAny({
+      isOptional: "optional"
+    });
+  }
+};
+var VObject = class _VObject extends BaseValidator {
+  /**
+   * Usually you'd use `v.object({ ... })` instead.
+   */
+  constructor({
+    isOptional,
+    fields
+  }) {
+    super({ isOptional });
+    __publicField(this, "fields");
+    __publicField(this, "kind", "object");
+    globalThis.Object.entries(fields).forEach(([fieldName, validator]) => {
+      if (validator === void 0) {
+        throwUndefinedValidatorError("v.object()", fieldName);
+      }
+      if (!validator.isConvexValidator) {
+        throw new Error("v.object() entries must be validators");
+      }
+    });
+    this.fields = fields;
+  }
+  /** @internal */
+  get json() {
+    return {
+      type: this.kind,
+      value: globalThis.Object.fromEntries(
+        globalThis.Object.entries(this.fields).map(([k, v2]) => [
+          k,
+          {
+            fieldType: v2.json,
+            optional: v2.isOptional === "optional" ? true : false
+          }
+        ])
+      )
+    };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VObject({
+      isOptional: "optional",
+      fields: this.fields
+    });
+  }
+  /**
+   * Create a new VObject with the specified fields omitted.
+   * @param fields The field names to omit from this VObject.
+   */
+  omit(...fields) {
+    const newFields = { ...this.fields };
+    for (const field of fields) {
+      delete newFields[field];
+    }
+    return new _VObject({
+      isOptional: this.isOptional,
+      fields: newFields
+    });
+  }
+  /**
+   * Create a new VObject with only the specified fields.
+   * @param fields The field names to pick from this VObject.
+   */
+  pick(...fields) {
+    const newFields = {};
+    for (const field of fields) {
+      newFields[field] = this.fields[field];
+    }
+    return new _VObject({
+      isOptional: this.isOptional,
+      fields: newFields
+    });
+  }
+  /**
+   * Create a new VObject with all fields marked as optional.
+   */
+  partial() {
+    const newFields = {};
+    for (const [key, validator] of globalThis.Object.entries(this.fields)) {
+      newFields[key] = validator.asOptional();
+    }
+    return new _VObject({
+      isOptional: this.isOptional,
+      fields: newFields
+    });
+  }
+  /**
+   * Create a new VObject with additional fields merged in.
+   * @param fields An object with additional validators to merge into this VObject.
+   */
+  extend(fields) {
+    return new _VObject({
+      isOptional: this.isOptional,
+      fields: { ...this.fields, ...fields }
+    });
+  }
+};
+var VLiteral = class _VLiteral extends BaseValidator {
+  /**
+   * Usually you'd use `v.literal(value)` instead.
+   */
+  constructor({ isOptional, value }) {
+    super({ isOptional });
+    __publicField(this, "value");
+    __publicField(this, "kind", "literal");
+    if (typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number" && typeof value !== "bigint") {
+      throw new Error("v.literal(value) must be a string, number, or boolean");
+    }
+    this.value = value;
+  }
+  /** @internal */
+  get json() {
+    return {
+      type: this.kind,
+      value: convexToJson(this.value)
+    };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VLiteral({
+      isOptional: "optional",
+      value: this.value
+    });
+  }
+};
+var VArray = class _VArray extends BaseValidator {
+  /**
+   * Usually you'd use `v.array(element)` instead.
+   */
+  constructor({
+    isOptional,
+    element
+  }) {
+    super({ isOptional });
+    __publicField(this, "element");
+    __publicField(this, "kind", "array");
+    if (element === void 0) {
+      throwUndefinedValidatorError("v.array()");
+    }
+    this.element = element;
+  }
+  /** @internal */
+  get json() {
+    return {
+      type: this.kind,
+      value: this.element.json
+    };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VArray({
+      isOptional: "optional",
+      element: this.element
+    });
+  }
+};
+var VRecord = class _VRecord extends BaseValidator {
+  /**
+   * Usually you'd use `v.record(key, value)` instead.
+   */
+  constructor({
+    isOptional,
+    key,
+    value
+  }) {
+    super({ isOptional });
+    __publicField(this, "key");
+    __publicField(this, "value");
+    __publicField(this, "kind", "record");
+    if (key === void 0) {
+      throwUndefinedValidatorError("v.record()", "key");
+    }
+    if (value === void 0) {
+      throwUndefinedValidatorError("v.record()", "value");
+    }
+    if (key.isOptional === "optional") {
+      throw new Error("Record validator cannot have optional keys");
+    }
+    if (value.isOptional === "optional") {
+      throw new Error("Record validator cannot have optional values");
+    }
+    if (!key.isConvexValidator || !value.isConvexValidator) {
+      throw new Error("Key and value of v.record() but be validators");
+    }
+    this.key = key;
+    this.value = value;
+  }
+  /** @internal */
+  get json() {
+    return {
+      type: this.kind,
+      // This cast is needed because TypeScript thinks the key type is too wide
+      keys: this.key.json,
+      values: {
+        fieldType: this.value.json,
+        optional: false
+      }
+    };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VRecord({
+      isOptional: "optional",
+      key: this.key,
+      value: this.value
+    });
+  }
+};
+var VUnion = class _VUnion extends BaseValidator {
+  /**
+   * Usually you'd use `v.union(...members)` instead.
+   */
+  constructor({ isOptional, members }) {
+    super({ isOptional });
+    __publicField(this, "members");
+    __publicField(this, "kind", "union");
+    members.forEach((member, index) => {
+      if (member === void 0) {
+        throwUndefinedValidatorError("v.union()", `member at index ${index}`);
+      }
+      if (!member.isConvexValidator) {
+        throw new Error("All members of v.union() must be validators");
+      }
+    });
+    this.members = members;
+  }
+  /** @internal */
+  get json() {
+    return {
+      type: this.kind,
+      value: this.members.map((v2) => v2.json)
+    };
+  }
+  /** @internal */
+  asOptional() {
+    return new _VUnion({
+      isOptional: "optional",
+      members: this.members
+    });
+  }
+};
+
+// ../node_modules/.pnpm/convex@1.31.6_react@19.2.0/node_modules/convex/dist/esm/values/validator.js
+var v = {
+  /**
+   * Validates that the value corresponds to an ID of a document in given table.
+   * @param tableName The name of the table.
+   */
+  id: (tableName) => {
+    return new VId({
+      isOptional: "required",
+      tableName
+    });
+  },
+  /**
+   * Validates that the value is of type Null.
+   */
+  null: () => {
+    return new VNull({ isOptional: "required" });
+  },
+  /**
+   * Validates that the value is of Convex type Float64 (Number in JS).
+   *
+   * Alias for `v.float64()`
+   */
+  number: () => {
+    return new VFloat64({ isOptional: "required" });
+  },
+  /**
+   * Validates that the value is of Convex type Float64 (Number in JS).
+   */
+  float64: () => {
+    return new VFloat64({ isOptional: "required" });
+  },
+  /**
+   * @deprecated Use `v.int64()` instead
+   */
+  bigint: () => {
+    return new VInt64({ isOptional: "required" });
+  },
+  /**
+   * Validates that the value is of Convex type Int64 (BigInt in JS).
+   */
+  int64: () => {
+    return new VInt64({ isOptional: "required" });
+  },
+  /**
+   * Validates that the value is of type Boolean.
+   */
+  boolean: () => {
+    return new VBoolean({ isOptional: "required" });
+  },
+  /**
+   * Validates that the value is of type String.
+   */
+  string: () => {
+    return new VString({ isOptional: "required" });
+  },
+  /**
+   * Validates that the value is of Convex type Bytes (constructed in JS via `ArrayBuffer`).
+   */
+  bytes: () => {
+    return new VBytes({ isOptional: "required" });
+  },
+  /**
+   * Validates that the value is equal to the given literal value.
+   * @param literal The literal value to compare against.
+   */
+  literal: (literal3) => {
+    return new VLiteral({ isOptional: "required", value: literal3 });
+  },
+  /**
+   * Validates that the value is an Array of the given element type.
+   * @param element The validator for the elements of the array.
+   */
+  array: (element) => {
+    return new VArray({ isOptional: "required", element });
+  },
+  /**
+   * Validates that the value is an Object with the given properties.
+   * @param fields An object specifying the validator for each property.
+   */
+  object: (fields) => {
+    return new VObject({ isOptional: "required", fields });
+  },
+  /**
+   * Validates that the value is a Record with keys and values that match the given types.
+   * @param keys The validator for the keys of the record. This cannot contain string literals.
+   * @param values The validator for the values of the record.
+   */
+  record: (keys, values) => {
+    return new VRecord({
+      isOptional: "required",
+      key: keys,
+      value: values
+    });
+  },
+  /**
+   * Validates that the value matches one of the given validators.
+   * @param members The validators to match against.
+   */
+  union: (...members) => {
+    return new VUnion({
+      isOptional: "required",
+      members
+    });
+  },
+  /**
+   * Does not validate the value.
+   */
+  any: () => {
+    return new VAny({ isOptional: "required" });
+  },
+  /**
+   * Allows not specifying a value for a property in an Object.
+   * @param value The property value validator to make optional.
+   *
+   * ```typescript
+   * const objectWithOptionalFields = v.object({
+   *   requiredField: v.string(),
+   *   optionalField: v.optional(v.string()),
+   * });
+   * ```
+   */
+  optional: (value) => {
+    return value.asOptional();
+  },
+  /**
+   * Allows specifying a value or null.
+   */
+  nullable: (value) => {
+    return v.union(value, v.null());
+  }
+};
+
+// ../node_modules/.pnpm/convex@1.31.6_react@19.2.0/node_modules/convex/dist/esm/values/compare_utf8.js
+var arr = () => Array.from({ length: 4 }, () => 0);
+arr();
+arr();
+
+// ../node_modules/.pnpm/convex-helpers@0.1.111_@sta_93c457dc952a51f4edfd5f2327f1d7a5/node_modules/convex-helpers/validators.js
+v.string();
+v.float64();
+v.float64();
+v.boolean();
+v.int64();
+v.int64();
+v.any();
+v.null();
+v.bytes();
+v.optional(v.any());
+
+// ../node_modules/.pnpm/convex-helpers@0.1.111_@sta_93c457dc952a51f4edfd5f2327f1d7a5/node_modules/convex-helpers/server/zod4.js
+var zid = (tableName) => {
+  const result = z2.custom((val) => typeof val === "string");
+  _zidRegistry.add(result, { tableName });
+  return result;
+};
+var _zidRegistry = zCore.registry();
+var BaseDocumentSchema = (tableName) => z$1.object({
+  _id: zid(tableName),
+  _creationTime: z$1.number()
+});
+
+// ../src/shared/types/convex/notification/notification.ts
+var BaseNotificationSchema = BaseDocumentSchema("notifications").extend({
+  organizationId: zid("organizations"),
+  read: z$1.boolean(),
+  title: z$1.string().min(1),
+  message: z$1.string()
+});
+var GeneralNotificationSchema = BaseNotificationSchema.extend({
+  category: z$1.literal("general"),
+  link: z$1.url().nullable()
+});
+var ChatNotificationSchema = BaseNotificationSchema.extend({
+  category: z$1.literal("chat"),
+  conversationId: zid("conversations")
+});
+var SpacesNotificationSchema = BaseNotificationSchema.extend({
+  category: z$1.literal("spaces"),
+  spaceUrlPath: z$1.string()
+});
+z$1.discriminatedUnion("category", [
+  GeneralNotificationSchema,
+  ChatNotificationSchema,
+  SpacesNotificationSchema
+]);
+var omitFields = { _id: true, _creationTime: true, organizationId: true, read: true };
+var BareGeneralNotificationSchema = GeneralNotificationSchema.omit(omitFields);
+var BareChatNotificationSchema = ChatNotificationSchema.omit(omitFields);
+var BareSpacesNotificationSchema = SpacesNotificationSchema.omit(omitFields);
+var BareNotificationSchema = z.discriminatedUnion("category", [
+  BareGeneralNotificationSchema,
+  BareChatNotificationSchema,
+  BareSpacesNotificationSchema
+]);
+var AssignTagsSchema = z$1.object({
+  waId: z$1.string().min(1, "WhatsApp ID is required"),
+  tags: z$1.array(z$1.string()).min(1, "At least one tag is required")
+});
+var SEND_OPTIONS = ["dashboard", "email", "push"];
+var SendNotificationSchema = z$1.object({
+  sendOptions: z$1.array(z$1.enum(SEND_OPTIONS)).min(1),
+  notification: BareNotificationSchema
+});
+var SendMessageSchema = z$1.object({
+  waId: z$1.string().min(1, "WhatsApp ID is required"),
+  message: z$1.discriminatedUnion("type", [
+    z$1.object({
+      type: z$1.literal("text"),
+      content: TextContent
+    }),
+    z$1.object({
+      type: z$1.literal("note"),
+      content: TextContent
+    }),
+    z$1.object({
+      type: z$1.literal("template"),
+      content: TemplateContent.omit({ renderedText: true })
+    })
+  ]),
+  clientName: z$1.string().optional()
+});
+var StopConversationAiSchema = z$1.object({
+  waId: z$1.string().min(1, "WhatsApp ID is required"),
+  stopAi: z$1.boolean()
+});
+var UpsertConversationSchema = z$1.object({
+  waId: z$1.string().min(1, "WhatsApp ID is required"),
+  clientName: z$1.string().min(1, "Client name is required")
+});
+
+// src/client.ts
+var KortexClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl || "https://kortex-dashboard.vercel.app";
+    this.apiToken = config.apiToken;
+  }
+  /**
+   * Internal method to make API requests
+   */
+  async request(endpoint, payload) {
+    const result = await HttpService.post(`${this.baseUrl}${endpoint}`, payload, {
+      Authorization: `Bearer ${this.apiToken}`
+    });
+    if (result.error) {
+      return err({
+        message: result.error.message
+      });
+    }
+    return ok(result.data);
+  }
+  /**
+   * Assign tags to a conversation
+   * @param payload - The waId and tags to assign
+   * @returns Result with the success message or error
+   */
+  async assignTags(payload) {
+    try {
+      const validated = AssignTagsSchema.parse(payload);
+      return this.request("/api/external/assign-tags", validated);
+    } catch (error) {
+      return err({ message: error instanceof Error ? error.message : "Validation error" });
+    }
+  }
+  /**
+   * Send a notification through specified channels
+   * @param payload - The notification and send options
+   * @returns Result with the success message or error
+   */
+  async sendNotification(payload) {
+    try {
+      const validated = SendNotificationSchema.parse(payload);
+      return this.request("/api/external/send-notification", validated);
+    } catch (error) {
+      return err({ message: error instanceof Error ? error.message : "Validation error" });
+    }
+  }
+  /**
+   * Send a message (text, note, or template) to a WhatsApp conversation
+   * @param payload - The message details (waId, message type and content)
+   * @returns Result with the success message or error
+   */
+  async sendMessage(payload) {
+    try {
+      const validated = SendMessageSchema.parse(payload);
+      return this.request("/api/external/send-template", validated);
+    } catch (error) {
+      return err({ message: error instanceof Error ? error.message : "Validation error" });
+    }
+  }
+  /**
+   * Stop or start AI for a conversation
+   * @param payload - The waId and stopAi boolean
+   * @returns Result with the success message or error
+   */
+  async stopConversationAi(payload) {
+    try {
+      const validated = StopConversationAiSchema.parse(payload);
+      return this.request("/api/external/stop-conversation-ai", validated);
+    } catch (error) {
+      return err({ message: error instanceof Error ? error.message : "Validation error" });
+    }
+  }
+  /**
+   * Create or update a conversation
+   * @param payload - The waId and client name
+   * @returns Result with the conversation data or error
+   */
+  async upsertConversation(payload) {
+    try {
+      const validated = UpsertConversationSchema.parse(payload);
+      return this.request("/api/external/upsert-conversation", validated);
+    } catch (error) {
+      return err({ message: error instanceof Error ? error.message : "Validation error" });
+    }
+  }
+};
+
+export { AssignTagsSchema, KortexClient, SendMessageSchema, SendNotificationSchema, StopConversationAiSchema, UpsertConversationSchema };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map