shipflow 0.1.1 → 0.3.0

package/dist/index-qnxj8bct.js

@@ -0,0 +1,1067 @@
+// src/core/errors.ts
+class ShipFlowError extends Error {
+  carrier;
+  code;
+  raw;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "ShipFlowError";
+    this.carrier = options?.carrier;
+    this.code = options?.code;
+    this.raw = options?.raw;
+  }
+}
+
+class NetworkError extends ShipFlowError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NetworkError";
+  }
+}
+
+class APIError extends ShipFlowError {
+  statusCode;
+  errors;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "APIError";
+    this.statusCode = options?.statusCode;
+    this.errors = options?.errors;
+  }
+}
+
+class RateLimitError extends APIError {
+  retryAfterMs;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RateLimitError";
+    this.retryAfterMs = options?.retryAfterMs;
+  }
+}
+
+class ValidationError extends ShipFlowError {
+  field;
+  issues;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ValidationError";
+    this.field = options?.field;
+    this.issues = options?.issues;
+  }
+}
+
+class AuthenticationError extends ShipFlowError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "AuthenticationError";
+  }
+}
+
+class WebhookVerificationError extends ShipFlowError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "WebhookVerificationError";
+  }
+}
+
+class UnsupportedOperationError extends ShipFlowError {
+  operation;
+  constructor(carrier, operation) {
+    super(`${carrier} does not support operation: ${operation}`, { carrier });
+    this.name = "UnsupportedOperationError";
+    this.operation = operation;
+  }
+}
+
+// ../../node_modules/.bun/valibot@1.4.1+7524df1edfed9f02/node_modules/valibot/dist/index.mjs
+var store$4;
+var DEFAULT_CONFIG = {
+  lang: undefined,
+  message: undefined,
+  abortEarly: undefined,
+  abortPipeEarly: undefined
+};
+function getGlobalConfig(config$1) {
+  if (!config$1 && !store$4)
+    return DEFAULT_CONFIG;
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string")
+    return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean")
+    return `${input}`;
+  if (type === "object" || type === "function")
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== undefined)
+    issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema)
+    dataset.typed = false;
+  if (dataset.issues)
+    dataset.issues.push(issue);
+  else
+    dataset.issues = [issue];
+}
+var _standardCache = /* @__PURE__ */ new WeakMap;
+function _getStandardProps(context) {
+  let cached = _standardCache.get(context);
+  if (!cached) {
+    cached = {
+      version: 1,
+      vendor: "valibot",
+      validate(value$1) {
+        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+      }
+    };
+    _standardCache.set(context, cached);
+  }
+  return cached;
+}
+function _isValidObjectKey(object$1, key) {
+  return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+function _joinExpects(values$1, separator) {
+  const list = [...new Set(values$1)];
+  if (list.length > 1)
+    return `(${list.join(` ${separator} `)})`;
+  return list[0] ?? "never";
+}
+function getDotPath(issue) {
+  if (issue.path) {
+    let key = "";
+    for (const item of issue.path)
+      if (typeof item.key === "string" || typeof item.key === "number")
+        if (key)
+          key += `.${item.key}`;
+        else
+          key += item.key;
+      else
+        return null;
+    return key;
+  }
+  return null;
+}
+var EMAIL_REGEX = /^[\w+-]+(?:\.[\w+-]+)*@[\da-z]+(?:[.-][\da-z]+)*\.[a-z]{2,}$/iu;
+function email(message$1) {
+  return {
+    kind: "validation",
+    type: "email",
+    reference: email,
+    expects: null,
+    async: false,
+    requirement: EMAIL_REGEX,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement.test(dataset.value))
+        _addIssue(this, "email", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function gtValue(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "gt_value",
+    reference: gtValue,
+    async: false,
+    expects: `>${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value > this.requirement))
+        _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+      return dataset;
+    }
+  };
+}
+function integer(message$1) {
+  return {
+    kind: "validation",
+    type: "integer",
+    reference: integer,
+    async: false,
+    expects: null,
+    requirement: Number.isInteger,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value))
+        _addIssue(this, "integer", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function length(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "length",
+    reference: length,
+    async: false,
+    expects: `${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && dataset.value.length !== this.requirement)
+        _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+      return dataset;
+    }
+  };
+}
+function maxValue(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "max_value",
+    reference: maxValue,
+    async: false,
+    expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value <= this.requirement))
+        _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+      return dataset;
+    }
+  };
+}
+function minLength(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_length",
+    reference: minLength,
+    async: false,
+    expects: `>=${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && dataset.value.length < this.requirement)
+        _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+      return dataset;
+    }
+  };
+}
+function minValue(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value >= this.requirement))
+        _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+      return dataset;
+    }
+  };
+}
+function regex(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "regex",
+    reference: regex,
+    async: false,
+    expects: `${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement.test(dataset.value))
+        _addIssue(this, "format", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+function getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+function array(item, message$1) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0;key < input.length; key++) {
+          const value$1 = input[key];
+          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value$1
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path)
+                issue.path.unshift(pathItem);
+              else
+                issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues)
+              dataset.issues = itemDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed)
+            dataset.typed = false;
+          dataset.value.push(itemDataset.value);
+        }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function boolean(message$1) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "boolean")
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function number(message$1) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value))
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== undefined) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path)
+                  issue.path.unshift(pathItem);
+                else
+                  issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed)
+              dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== undefined)
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: undefined,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly)
+              break;
+          }
+        }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === undefined) {
+        if (this.default !== undefined)
+          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === undefined) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+function picklist(options, message$1) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (this.options.includes(dataset.value))
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function record(key, value$1, message$1) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input)
+          if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+            const entryValue = input[entryKey];
+            const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+            if (keyDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "key",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of keyDataset.issues) {
+                issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = keyDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path)
+                  issue.path.unshift(pathItem);
+                else
+                  issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues)
+                dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!keyDataset.typed || !valueDataset.typed)
+              dataset.typed = false;
+            if (keyDataset.typed)
+              dataset.value[keyDataset.value] = valueDataset.value;
+          }
+      } else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string")
+        dataset.typed = true;
+      else
+        _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+function unknown() {
+  return {
+    kind: "schema",
+    type: "unknown",
+    reference: unknown,
+    expects: "unknown",
+    async: false,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+function pipe(...pipe$1) {
+  return {
+    ...pipe$1[0],
+    pipe: pipe$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      for (const item of pipe$1)
+        if (item.kind !== "metadata") {
+          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+            dataset.typed = false;
+            break;
+          }
+          if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly)
+            dataset = item["~run"](dataset, config$1);
+        }
+      return dataset;
+    }
+  };
+}
+function safeParse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// src/core/schemas.ts
+var NationalAddressSchema = object({
+  shortCode: pipe(string(), minLength(1)),
+  buildingNumber: optional(string()),
+  streetName: optional(string()),
+  district: optional(string()),
+  additionalNumber: optional(string())
+});
+var AddressSchema = object({
+  name: pipe(string(), minLength(1, "Name is required")),
+  company: optional(string()),
+  email: optional(pipe(string(), email("Invalid email format"))),
+  phone: pipe(string(), minLength(1, "Phone is required")),
+  line1: pipe(string(), minLength(1, "Address line 1 is required")),
+  line2: optional(string()),
+  neighbourhood: optional(string()),
+  city: pipe(string(), minLength(1, "City is required")),
+  state: optional(string()),
+  postalCode: optional(string()),
+  countryCode: pipe(string(), length(2, "Country code must be ISO 3166-1 alpha-2 (2 characters)")),
+  coordinates: optional(object({
+    latitude: pipe(number(), minValue(-90), maxValue(90)),
+    longitude: pipe(number(), minValue(-180), maxValue(180))
+  })),
+  description: optional(string()),
+  nationalAddress: optional(NationalAddressSchema)
+});
+var WeightSchema = object({
+  value: pipe(number(), gtValue(0, "Weight must be positive")),
+  unit: picklist(["kg", "lb"])
+});
+var DimensionsSchema = object({
+  length: pipe(number(), gtValue(0, "Length must be positive")),
+  width: pipe(number(), gtValue(0, "Width must be positive")),
+  height: pipe(number(), gtValue(0, "Height must be positive")),
+  unit: picklist(["cm", "in"])
+});
+var ParcelSchema = object({
+  weight: WeightSchema,
+  dimensions: optional(DimensionsSchema),
+  pieces: pipe(number(), integer(), gtValue(0, "Pieces must be a positive integer")),
+  itemsCount: optional(pipe(number(), integer(), gtValue(0))),
+  description: optional(string())
+});
+var CODDetailsSchema = object({
+  enabled: boolean(),
+  amount: pipe(number(), minValue(0, "COD amount must be non-negative")),
+  currency: pipe(string(), minLength(1, "COD currency is required"))
+});
+var DeclaredValueSchema = object({
+  amount: pipe(number(), minValue(0, "Declared value must be non-negative")),
+  currency: pipe(string(), minLength(1, "Currency is required"))
+});
+var InternationalMetadataSchema = object({
+  taxId: optional(string()),
+  invoiceNumber: optional(string()),
+  invoiceDate: optional(string()),
+  documentId: optional(number())
+});
+var ShipmentOptionsSchema = object({
+  requestedBy: optional(string()),
+  isInsured: optional(boolean()),
+  customerTracking: optional(string()),
+  fulfilmentCustomerName: optional(string()),
+  internationalMetadata: optional(InternationalMetadataSchema),
+  metadata: optional(record(string(), unknown()))
+});
+var CreateShipmentInputSchema = object({
+  shipper: AddressSchema,
+  consignee: AddressSchema,
+  parcels: pipe(array(ParcelSchema), minLength(1, "At least one parcel is required")),
+  serviceType: optional(pipe(string(), minLength(1))),
+  reference: optional(string()),
+  cod: optional(CODDetailsSchema),
+  declaredValue: optional(DeclaredValueSchema),
+  labelFormat: optional(picklist(["PDF", "ZPL", "PNG"])),
+  options: optional(ShipmentOptionsSchema)
+});
+var PickupRequestSchema = object({
+  date: pipe(string(), regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be YYYY-MM-DD format")),
+  timeSlot: pipe(string(), minLength(1, "Time slot is required")),
+  city: pipe(string(), minLength(1, "City is required")),
+  contactName: pipe(string(), minLength(1, "Contact name is required")),
+  contactPhone: pipe(string(), minLength(1, "Contact phone is required")),
+  address: pipe(string(), minLength(1, "Address is required")),
+  shipmentCount: pipe(number(), integer(), gtValue(0, "Shipment count must be a positive integer")),
+  trackingNumbers: optional(array(string()))
+});
+var WebhookConfigSchema = object({
+  authHeader: optional(string()),
+  authValue: optional(string()),
+  authQueryParam: optional(string()),
+  authQueryValue: optional(string())
+});
+function formatIssues(issues) {
+  return issues.map((issue) => ({
+    path: getDotPath(issue) ?? "",
+    message: issue.message
+  }));
+}
+function validateCreateShipmentInput(input) {
+  const result = safeParse(CreateShipmentInputSchema, input);
+  if (!result.success) {
+    throw new ValidationError("Invalid shipment input", {
+      issues: formatIssues(result.issues),
+      raw: input
+    });
+  }
+  return result.output;
+}
+function validatePickupRequest(input) {
+  const result = safeParse(PickupRequestSchema, input);
+  if (!result.success) {
+    throw new ValidationError("Invalid pickup request", {
+      issues: formatIssues(result.issues),
+      raw: input
+    });
+  }
+  return result.output;
+}
+
+// src/carriers/base.ts
+class BaseCarrierAdapter {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async createShipment(input) {
+    validateCreateShipmentInput(input);
+    return this.executeCreateShipment(input);
+  }
+}
+
+// src/core/retry.ts
+import { setTimeout as sleep } from "node:timers/promises";
+async function withRetry(fn, options) {
+  const {
+    retries,
+    baseMs = 500,
+    maxMs = 20000,
+    inlineCapMs = 15000,
+    shouldRetry,
+    retryAfterMs,
+    signal
+  } = options;
+  for (let attempt = 0;; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt >= retries || !shouldRetry(error))
+        throw error;
+      const retryAfter = retryAfterMs?.(error);
+      let delay;
+      if (retryAfter != null) {
+        if (retryAfter > inlineCapMs)
+          throw error;
+        delay = retryAfter + Math.random() * 1000;
+      } else {
+        delay = Math.random() * Math.min(maxMs, baseMs * 2 ** attempt);
+      }
+      try {
+        await sleep(delay, undefined, { signal });
+      } catch {
+        throw error;
+      }
+    }
+  }
+}
+function parseRetryAfter(headerValue) {
+  if (headerValue == null)
+    return;
+  const trimmed = headerValue.trim();
+  if (trimmed === "")
+    return;
+  if (/^\d+$/.test(trimmed))
+    return Number(trimmed) * 1000;
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date))
+    return;
+  return Math.max(0, date - Date.now());
+}
+
+// src/core/http.ts
+class HttpClient {
+  config;
+  retryConfig;
+  static DEFAULT_RETRYABLE = [429, 500, 502, 503, 504];
+  static SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+  constructor(config) {
+    this.config = {
+      ...config,
+      timeout: config.timeout ?? 30000
+    };
+    const retry = config.retry === false ? { retries: 0 } : config.retry ?? {};
+    this.retryConfig = {
+      retries: retry.retries ?? 2,
+      retryableStatuses: retry.retryableStatuses ?? HttpClient.DEFAULT_RETRYABLE,
+      baseMs: retry.baseMs ?? 500,
+      maxMs: retry.maxMs ?? 20000,
+      inlineCapMs: retry.inlineCapMs ?? 15000
+    };
+  }
+  async request(endpoint, options = {}) {
+    const method = options.method ?? "GET";
+    const shouldRetry = this.shouldRetry(method, options.retry);
+    if (!shouldRetry) {
+      return this.executeRequest(endpoint, options);
+    }
+    return withRetry(() => this.executeRequest(endpoint, options), {
+      retries: this.retryConfig.retries,
+      baseMs: this.retryConfig.baseMs,
+      maxMs: this.retryConfig.maxMs,
+      inlineCapMs: this.retryConfig.inlineCapMs,
+      shouldRetry: (error) => this.isRetryable(error),
+      retryAfterMs: (error) => error instanceof RateLimitError ? error.retryAfterMs : undefined,
+      signal: options.signal
+    });
+  }
+  shouldRetry(method, requestRetry) {
+    if (this.retryConfig.retries === 0)
+      return false;
+    if (requestRetry !== undefined)
+      return requestRetry;
+    return HttpClient.SAFE_METHODS.has(method);
+  }
+  isRetryable(error) {
+    if (error instanceof NetworkError)
+      return true;
+    if (error instanceof RateLimitError)
+      return true;
+    if (error instanceof APIError && error.statusCode != null) {
+      return this.retryConfig.retryableStatuses.includes(error.statusCode);
+    }
+    return false;
+  }
+  async executeRequest(endpoint, options = {}) {
+    const {
+      method = "GET",
+      headers = {},
+      body,
+      params,
+      errorExtractor,
+      signal: callerSignal
+    } = options;
+    let url = `${this.config.baseUrl}${endpoint}`;
+    if (params) {
+      const searchParams = new URLSearchParams;
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+          searchParams.set(key, String(value));
+        }
+      }
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    const timeoutSignal = AbortSignal.timeout(this.config.timeout);
+    const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...this.config.headers,
+          ...headers
+        },
+        body: body ? JSON.stringify(body) : undefined,
+        signal
+      });
+      let json;
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json")) {
+        json = await response.json();
+      } else {
+        const text = await response.text();
+        try {
+          json = JSON.parse(text);
+        } catch {
+          json = text;
+        }
+      }
+      if (!response.ok) {
+        const retryAfterMs = response.status === 429 || response.status === 503 ? parseRetryAfter(response.headers.get("retry-after")) : undefined;
+        this.handleHttpError(response.status, json, retryAfterMs);
+      }
+      if (errorExtractor) {
+        const extracted = errorExtractor(json);
+        if (extracted.hasError) {
+          if (extracted.rateLimited) {
+            throw new RateLimitError(extracted.message ?? "Carrier rate limit", {
+              carrier: this.config.carrier,
+              statusCode: 200,
+              errors: extracted.errors,
+              retryAfterMs: extracted.retryAfterMs,
+              raw: json
+            });
+          }
+          throw new APIError(extracted.message ?? "API returned an error", {
+            carrier: this.config.carrier,
+            statusCode: 200,
+            errors: extracted.errors,
+            raw: json
+          });
+        }
+      }
+      return json;
+    } catch (error) {
+      if (error instanceof ShipFlowError) {
+        throw error;
+      }
+      if (callerSignal?.aborted) {
+        throw error;
+      }
+      if (error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError")) {
+        throw new NetworkError(`Request timeout after ${this.config.timeout}ms`, {
+          carrier: this.config.carrier
+        });
+      }
+      if (error instanceof TypeError && error.message.includes("fetch")) {
+        throw new NetworkError(`Network error: ${error.message}`, {
+          carrier: this.config.carrier,
+          cause: error
+        });
+      }
+      throw new NetworkError(`Unexpected error: ${error.message}`, {
+        carrier: this.config.carrier,
+        cause: error
+      });
+    }
+  }
+  handleHttpError(status, json, retryAfterMs) {
+    const message = this.extractErrorMessage(json) ?? `HTTP ${status}`;
+    if (status === 401) {
+      throw new AuthenticationError(message, {
+        carrier: this.config.carrier,
+        raw: json
+      });
+    }
+    if (status === 429 || status === 503) {
+      throw new RateLimitError(message, {
+        carrier: this.config.carrier,
+        statusCode: status,
+        errors: this.extractValidationErrors(json),
+        retryAfterMs,
+        raw: json
+      });
+    }
+    throw new APIError(message, {
+      carrier: this.config.carrier,
+      statusCode: status,
+      errors: this.extractValidationErrors(json),
+      raw: json
+    });
+  }
+  extractErrorMessage(json) {
+    if (typeof json === "string")
+      return json.trim() || undefined;
+    if (!json || typeof json !== "object")
+      return;
+    const obj = json;
+    if (typeof obj.message === "string")
+      return obj.message;
+    if (typeof obj.error === "string")
+      return obj.error;
+    if (typeof obj.response === "string")
+      return obj.response;
+    if (obj.Message && typeof obj.Message === "string")
+      return obj.Message;
+    return;
+  }
+  extractValidationErrors(json) {
+    if (!json || typeof json !== "object")
+      return;
+    const obj = json;
+    if (obj.errors && typeof obj.errors === "object") {
+      return obj.errors;
+    }
+    return;
+  }
+  get(endpoint, options) {
+    return this.request(endpoint, { ...options, method: "GET" });
+  }
+  post(endpoint, body, options) {
+    return this.request(endpoint, { ...options, method: "POST", body });
+  }
+  put(endpoint, body, options) {
+    return this.request(endpoint, { ...options, method: "PUT", body });
+  }
+  delete(endpoint, options) {
+    return this.request(endpoint, { ...options, method: "DELETE" });
+  }
+}
+
+export { ShipFlowError, NetworkError, APIError, RateLimitError, ValidationError, AuthenticationError, WebhookVerificationError, UnsupportedOperationError, AddressSchema, WeightSchema, DimensionsSchema, ParcelSchema, CODDetailsSchema, DeclaredValueSchema, CreateShipmentInputSchema, PickupRequestSchema, WebhookConfigSchema, validateCreateShipmentInput, validatePickupRequest, BaseCarrierAdapter, HttpClient };
+
+//# debugId=B88EAD18635FEEDC64756E2164756E21