postnl-client 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2017 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/config.ts
+var BASE_URLS = {
+  production: "https://api.postnl.nl",
+  sandbox: "https://api-sandbox.postnl.nl"
+};
+var DEFAULT_RETRY = {
+  maxRetries: 3,
+  backoffFactor: 2,
+  retryStatuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+  retryMethods: ["GET", "PUT"]
+};
+function resolveConfig(opts) {
+  if (!opts?.apiKey) throw new Error("postnl-client: apiKey is required");
+  const environment = opts.environment ?? "production";
+  const f = opts.fetch ?? globalThis.fetch;
+  if (!f) throw new Error("postnl-client: no fetch available; pass options.fetch");
+  return {
+    apiKey: opts.apiKey,
+    environment,
+    baseUrl: BASE_URLS[environment],
+    fetch: f,
+    timeoutMs: opts.timeoutMs ?? 6e4,
+    retry: { ...DEFAULT_RETRY, ...opts.retry },
+    hooks: opts.hooks ?? {}
+  };
+}
+
+// src/core/errors.ts
+var PostNLError = class extends Error {
+};
+var PostNLValidationError = class extends PostNLError {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "PostNLValidationError";
+  }
+  issues;
+};
+var PostNLTimeoutError = class extends PostNLError {
+  constructor(timeoutMs) {
+    super(`postnl request timed out after ${timeoutMs}ms`);
+    this.timeoutMs = timeoutMs;
+    this.name = "PostNLTimeoutError";
+  }
+  timeoutMs;
+};
+var PostNLApiError = class extends PostNLError {
+  constructor(status, message, code, detail, raw) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.detail = detail;
+    this.raw = raw;
+    this.name = "PostNLApiError";
+  }
+  status;
+  code;
+  detail;
+  raw;
+};
+var PostNLAuthError = class extends PostNLApiError {
+  name = "PostNLAuthError";
+};
+var PostNLRateLimitError = class extends PostNLApiError {
+  retryAfter;
+  name = "PostNLRateLimitError";
+};
+var PostNLMethodNotAllowedError = class extends PostNLApiError {
+  name = "PostNLMethodNotAllowedError";
+};
+var PostNLBadRequestError = class extends PostNLApiError {
+  name = "PostNLBadRequestError";
+};
+var PostNLServerError = class extends PostNLApiError {
+  name = "PostNLServerError";
+};
+function extract(body) {
+  const b = body;
+  if (b && typeof b === "object") {
+    const fault = b.fault;
+    if (fault)
+      return {
+        message: fault.faultstring ?? "fault",
+        code: fault.detail?.errorcode,
+        detail: fault
+      };
+    const inv = b.Error;
+    if (inv?.ErrorDescription)
+      return { message: inv.ErrorDescription, code: inv.ErrorCode, detail: b };
+    const list = b.errors ?? b.Errors;
+    if (Array.isArray(list) && list.length) {
+      const f = list[0];
+      const msg = f.ErrorMsg ?? f.Error ?? f.title ?? f.Description ?? f.detail ?? "error";
+      const code = f.ErrorNumber ?? f.Code ?? f.status;
+      return { message: String(msg), code: code != null ? String(code) : void 0, detail: list };
+    }
+    if (typeof b.title === "string")
+      return { message: b.title, code: b.type, detail: b };
+    if (typeof b.message === "string") return { message: b.message, detail: b };
+  }
+  return { message: `postnl request failed (${typeof body})`, detail: body };
+}
+function parseError(status, body, headers) {
+  const { message, code, detail } = extract(body);
+  if (status === 401) return new PostNLAuthError(status, message, code, detail, body);
+  if (status === 429) {
+    const err = new PostNLRateLimitError(status, message, code, detail, body);
+    const ra = Number(headers?.["retry-after"]);
+    if (Number.isFinite(ra)) err.retryAfter = ra;
+    return err;
+  }
+  if (status === 405) return new PostNLMethodNotAllowedError(status, message, code, detail, body);
+  if (status >= 500) return new PostNLServerError(status, message, code, detail, body);
+  if (status === 400) return new PostNLBadRequestError(status, message, code, detail, body);
+  return new PostNLApiError(status, message, code, detail, body);
+}
+
+// src/core/http.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var Transport = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  buildUrl(args) {
+    let path = args.path;
+    for (const [k, v] of Object.entries(args.pathParams ?? {})) {
+      path = path.replace(`{${k}}`, encodeURIComponent(v));
+    }
+    const url = new URL(this.cfg.baseUrl + path);
+    for (const [k, v] of Object.entries(args.query ?? {})) {
+      if (v === void 0) continue;
+      if (Array.isArray(v)) for (const item of v) url.searchParams.append(k, String(item));
+      else url.searchParams.append(k, String(v));
+    }
+    return url.toString();
+  }
+  async send(args) {
+    const url = this.buildUrl(args);
+    const headers = { apikey: this.cfg.apiKey, accept: "application/json" };
+    if (args.body !== void 0) headers["content-type"] = "application/json";
+    const ctx = {
+      family: args.family,
+      method: args.method,
+      url,
+      headers,
+      body: args.body
+    };
+    await this.cfg.hooks.onRequest?.(ctx);
+    const canRetry = this.cfg.retry.retryMethods.includes(args.method);
+    let attempt = 0;
+    while (true) {
+      const controller = new AbortController();
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, this.cfg.timeoutMs);
+      try {
+        const res = await this.cfg.fetch(url, {
+          method: args.method,
+          headers,
+          body: args.body !== void 0 ? JSON.stringify(args.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        const text = await res.text();
+        const headerObj = Object.fromEntries(res.headers.entries());
+        let body;
+        try {
+          body = text ? JSON.parse(text) : void 0;
+        } catch {
+          if (!res.ok) {
+            const err3 = parseError(res.status, text, headerObj);
+            await this.cfg.hooks.onError?.(err3);
+            throw err3;
+          }
+          const err2 = new PostNLApiError(
+            res.status,
+            "invalid json response",
+            void 0,
+            void 0,
+            text
+          );
+          await this.cfg.hooks.onError?.(err2);
+          throw err2;
+        }
+        if (res.ok) {
+          await this.cfg.hooks.onResponse?.({ request: ctx, status: res.status, body });
+          return body;
+        }
+        if (canRetry && this.cfg.retry.retryStatuses.includes(res.status) && attempt < this.cfg.retry.maxRetries) {
+          attempt++;
+          await sleep(this.retryDelay(attempt, res.status, headerObj));
+          continue;
+        }
+        const err = parseError(res.status, body, headerObj);
+        await this.cfg.hooks.onError?.(err);
+        throw err;
+      } catch (e2) {
+        clearTimeout(timer);
+        if (e2 instanceof PostNLApiError) throw e2;
+        if (canRetry && this.isRetryable(e2) && attempt < this.cfg.retry.maxRetries) {
+          attempt++;
+          await sleep(this.cfg.retry.backoffFactor * 2 ** (attempt - 1) * 100);
+          continue;
+        }
+        const surfaced = timedOut ? new PostNLTimeoutError(this.cfg.timeoutMs) : e2;
+        await this.cfg.hooks.onError?.(surfaced);
+        throw surfaced;
+      }
+    }
+  }
+  retryDelay(attempt, status, headers) {
+    if (status === 429) {
+      const ra = Number(headers["retry-after"]);
+      if (Number.isFinite(ra)) return ra * 1e3;
+    }
+    return this.cfg.retry.backoffFactor * 2 ** (attempt - 1) * 100;
+  }
+  // only retry genuine network failures: our timeout abort, or a fetch
+  // network-level TypeError. bad-url/bad-init TypeErrors should not retry.
+  isRetryable(e2) {
+    if (e2?.name === "AbortError") return true;
+    if (!(e2 instanceof TypeError)) return false;
+    const msg = `${e2.message} ${String(e2.cause ?? "")}`.toLowerCase();
+    return /fetch|network|connect|econn|enotfound|socket|timeout|terminated/.test(msg);
+  }
+};
+
+// src/core/endpoints.ts
+var e = (family, method, path) => ({
+  family,
+  method,
+  path
+});
+var ENDPOINTS = {
+  barcodeV4: e("v4", "POST", "/shipment/delivery/v4/barcode"),
+  shippingCreate: e("v4", "POST", "/shipment/delivery/v4/labelconfirm"),
+  shippingLabelV4: e("v4", "POST", "/shipment/delivery/v4/label"),
+  shippingConfirmV4: e("v4", "POST", "/shipment/delivery/v4/confirm"),
+  returnGenerate: e("v4", "POST", "/shipment/delivery/v4/return/generate"),
+  barcodeLegacy: e("legacy", "GET", "/shipment/v1_1/barcode"),
+  shippingLabelLegacy: e("legacy", "POST", "/shipment/v2_2/label"),
+  shippingConfirmLegacy: e("legacy", "POST", "/shipment/v2/confirm"),
+  trackingByBarcode: e("legacy", "GET", "/shipment/v2/status/barcode/{barcode}"),
+  trackingByReference: e("legacy", "GET", "/shipment/v2/status/reference/{referenceId}"),
+  trackingSignature: e("legacy", "GET", "/shipment/v2/status/signature/{barcode}"),
+  trackingUpdated: e("legacy", "GET", "/shipment/v2/status/{customernumber}/updatedshipments"),
+  deliveryDateCalculate: e("legacy", "GET", "/shipment/v2_2/calculate/date/delivery"),
+  deliveryDateSent: e("legacy", "GET", "/shipment/v2_2/calculate/date/shipping"),
+  timeframeGet: e("legacy", "GET", "/shipment/v2_1/calculate/timeframes"),
+  locationNearest: e("legacy", "GET", "/shipment/v2_1/locations/nearest"),
+  locationNearestByGeocode: e("legacy", "GET", "/shipment/v2_1/locations/nearest/geocode"),
+  locationArea: e("legacy", "GET", "/shipment/v2_1/locations/area"),
+  locationLookup: e("legacy", "GET", "/shipment/v2_1/locations/lookup"),
+  checkoutGet: e("legacy", "POST", "/shipment/v1/checkout"),
+  addressCheck: e("legacy", "GET", "/shipment/checkout/v1/postalcodecheck")
+};
+
+// src/core/base-resource.ts
+var BaseResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async call(args) {
+    const ep = ENDPOINTS[args.operation];
+    let body;
+    if (args.requestSchema && args.input !== void 0) {
+      const parsed = args.requestSchema.safeParse(args.input);
+      if (!parsed.success) throw new PostNLValidationError("invalid request", parsed.error.issues);
+      body = parsed.data;
+    } else {
+      body = args.input;
+    }
+    const raw = await this.transport.send({
+      family: ep.family,
+      method: ep.method,
+      path: ep.path,
+      pathParams: args.pathParams,
+      query: args.query,
+      body: ep.method === "GET" ? void 0 : body
+    });
+    const out = args.responseSchema.safeParse(raw);
+    if (!out.success) throw new PostNLValidationError("invalid response", out.error.issues);
+    return out.data;
+  }
+};
+function pnlArray(inner) {
+  return zod.z.preprocess((v) => {
+    if (v == null) return [];
+    if (Array.isArray(v)) return v;
+    if (typeof v === "object" && v !== null && "string" in v) {
+      const wrapped = v.string;
+      return Array.isArray(wrapped) ? wrapped : [wrapped];
+    }
+    return [v];
+  }, zod.z.array(inner));
+}
+function pnlStringWrapped(inner) {
+  return zod.z.preprocess((v) => {
+    if (v != null && typeof v === "object" && "string" in v) {
+      return v.string;
+    }
+    return v;
+  }, inner);
+}
+function pnlNum() {
+  return zod.z.preprocess(
+    (v) => typeof v === "string" && v.trim() !== "" ? Number(v) : v,
+    zod.z.number()
+  );
+}
+
+// src/core/codec/object.ts
+var stripUndefined = (obj) => {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+};
+
+// src/resources/address/schema.ts
+var postalcodeCheckAddressSchema = zod.z.object({
+  city: zod.z.string().optional(),
+  postalCode: zod.z.string().optional(),
+  streetName: zod.z.string().optional(),
+  houseNumber: pnlNum().optional(),
+  houseNumberAddition: zod.z.string().optional(),
+  formattedAddress: pnlArray(zod.z.string()).optional()
+}).transform(
+  (a) => stripUndefined({
+    city: a.city,
+    postalCode: a.postalCode,
+    streetName: a.streetName,
+    houseNumber: a.houseNumber,
+    houseNumberAddition: a.houseNumberAddition,
+    formattedAddress: a.formattedAddress?.length ? a.formattedAddress : void 0
+  })
+);
+
+// src/resources/address/index.ts
+var AddressResource = class extends BaseResource {
+  constructor(transport, environment) {
+    super(transport);
+    this.environment = environment;
+  }
+  environment;
+  // GET /shipment/checkout/v1/postalcodecheck
+  check(input) {
+    if (this.environment === "sandbox") {
+      return Promise.reject(
+        new PostNLError("address.check is production-only and not available on sandbox")
+      );
+    }
+    return this.call({
+      operation: "addressCheck",
+      query: {
+        postalcode: input.postalCode,
+        housenumber: String(input.houseNumber),
+        housenumberaddition: input.houseNumberAddition
+      },
+      responseSchema: postalcodeCheckAddressSchema
+    });
+  }
+};
+var responseSchema = zod.z.object({ Barcode: zod.z.string() }).transform((r) => ({ barcode: r.Barcode }));
+var BarcodeLegacyResource = class extends BaseResource {
+  generate(input) {
+    return this.call({
+      operation: "barcodeLegacy",
+      query: {
+        CustomerCode: input.customerCode,
+        CustomerNumber: input.customerNumber,
+        Type: input.type,
+        Serie: input.serie,
+        Range: input.range
+      },
+      responseSchema
+    });
+  }
+};
+var barcodeV4RequestSchema = zod.z.object({
+  customerNumber: zod.z.string(),
+  customerCode: zod.z.string(),
+  serieStart: zod.z.string().default("000000000"),
+  serieEnd: zod.z.string().default("999999999"),
+  numberOfBarcodes: zod.z.number().int().min(1).default(1)
+});
+var barcodeV4ResponseSchema = zod.z.object({
+  barcodes: zod.z.array(zod.z.string()).default([])
+});
+
+// src/resources/barcode/index.ts
+var BarcodeResource = class extends BaseResource {
+  // legacy barcode generation (GET /shipment/v1_1/barcode)
+  legacy = new BarcodeLegacyResource(this.transport);
+  // v4 server-side barcode generation
+  generate(input) {
+    return this.call({
+      operation: "barcodeV4",
+      input,
+      requestSchema: barcodeV4RequestSchema,
+      responseSchema: barcodeV4ResponseSchema
+    });
+  }
+};
+
+// src/core/codec/dates.ts
+var pad = (n) => String(n).padStart(2, "0");
+var num = (v) => Number(v ?? 0);
+var ISO = /^\d{4}-\d{2}-\d{2}$/;
+var NL_DATE = /^\d{2}-\d{2}-\d{4}$/;
+var NL_DATETIME = /^\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}$/;
+function parsePnlDate(input) {
+  const trimmed = input.trim();
+  const [datePart = "", timePart] = trimmed.split(" ");
+  let y;
+  let mo;
+  let d;
+  if (ISO.test(trimmed)) {
+    const [yy, mm, dd] = datePart.split("-");
+    y = num(yy);
+    mo = num(mm);
+    d = num(dd);
+  } else if (NL_DATE.test(trimmed) || NL_DATETIME.test(trimmed)) {
+    const [dd, mm, yy] = datePart.split("-");
+    y = num(yy);
+    mo = num(mm);
+    d = num(dd);
+  } else {
+    throw new Error(`invalid postnl date: ${input}`);
+  }
+  const [hh, mi, ss] = (timePart ?? "00:00:00").split(":");
+  return new Date(y, mo - 1, d, num(hh), num(mi), num(ss));
+}
+function formatDate(date, kind) {
+  const d = `${pad(date.getDate())}-${pad(date.getMonth() + 1)}-${date.getFullYear()}`;
+  if (kind === "date") return d;
+  return `${d} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function formatIsoDate(date) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+var pnlDateField = zod.z.string().optional().transform((v) => v == null ? void 0 : parsePnlDate(v));
+var sustainabilitySchema = zod.z.object({ Code: zod.z.string().optional(), Description: zod.z.string().optional() }).transform((s) => stripUndefined({ code: s.Code, description: s.Description }));
+
+// src/resources/checkout/schema.ts
+function toCheckoutRequestBody(input, orderDate) {
+  return stripUndefined({
+    OrderDate: orderDate,
+    CutOffTimes: input.cutOffTimes.map(
+      (c) => stripUndefined({ Day: c.day, Available: c.available, Type: c.type, Time: c.time })
+    ),
+    Options: [...input.options],
+    Locations: input.locations,
+    Days: input.days,
+    Addresses: input.addresses.map(
+      (a) => stripUndefined({
+        AddressType: a.addressType,
+        HouseNr: a.houseNr,
+        Zipcode: a.zipcode,
+        Countrycode: a.countrycode,
+        Street: a.street,
+        HouseNrExt: a.houseNrExt,
+        City: a.city
+      })
+    ),
+    ShippingDuration: input.shippingDuration,
+    HolidaySorting: input.holidaySorting
+  });
+}
+var timeframeSchema = zod.z.object({
+  From: zod.z.string().optional(),
+  To: zod.z.string().optional(),
+  Options: pnlArray(zod.z.string()),
+  ShippingDate: pnlDateField,
+  Sustainability: sustainabilitySchema.optional()
+}).transform(
+  (t) => stripUndefined({
+    from: t.From,
+    to: t.To,
+    options: t.Options.length ? t.Options : void 0,
+    shippingDate: t.ShippingDate,
+    sustainability: t.Sustainability
+  })
+);
+var deliveryOptionSchema = zod.z.object({
+  DeliveryDate: pnlDateField,
+  Timeframe: pnlArray(timeframeSchema)
+}).transform((d) => ({
+  ...stripUndefined({ deliveryDate: d.DeliveryDate }),
+  timeframe: d.Timeframe
+}));
+var pickupAddressSchema = zod.z.object({
+  Street: zod.z.string().optional(),
+  Zipcode: zod.z.string().optional(),
+  HouseNr: pnlNum().optional(),
+  HouseNrExt: zod.z.string().optional(),
+  Countrycode: zod.z.string().optional(),
+  CompanyName: zod.z.string().optional()
+}).transform(
+  (a) => stripUndefined({
+    street: a.Street,
+    zipcode: a.Zipcode,
+    houseNr: a.HouseNr,
+    houseNrExt: a.HouseNrExt,
+    countrycode: a.Countrycode,
+    companyName: a.CompanyName
+  })
+);
+var openingHoursPerDaySchema = zod.z.object({ From: zod.z.string().optional(), To: zod.z.string().optional() }).transform((d) => stripUndefined({ from: d.From, to: d.To }));
+var day = openingHoursPerDaySchema.optional();
+var pickupOpeningHoursSchema = zod.z.object({
+  Monday: day,
+  Tuesday: day,
+  Wednesday: day,
+  Thursday: day,
+  Friday: day,
+  Saturday: day,
+  Sunday: day
+}).transform(
+  (o) => stripUndefined({
+    monday: o.Monday,
+    tuesday: o.Tuesday,
+    wednesday: o.Wednesday,
+    thursday: o.Thursday,
+    friday: o.Friday,
+    saturday: o.Saturday,
+    sunday: o.Sunday
+  })
+);
+var checkoutLocationSchema = zod.z.object({
+  Address: pickupAddressSchema.optional(),
+  PickupTime: zod.z.string().optional(),
+  OpeningHours: pickupOpeningHoursSchema.optional(),
+  Distance: pnlNum().optional(),
+  LocationCode: zod.z.string().optional(),
+  PartnerID: zod.z.string().optional(),
+  Sustainability: sustainabilitySchema.optional()
+}).transform(
+  (l) => stripUndefined({
+    address: l.Address,
+    pickupTime: l.PickupTime,
+    openingHours: l.OpeningHours,
+    distance: l.Distance,
+    locationCode: l.LocationCode,
+    partnerId: l.PartnerID,
+    sustainability: l.Sustainability
+  })
+);
+var pickupOptionSchema = zod.z.object({
+  PickupDate: pnlDateField,
+  ShippingDate: pnlDateField,
+  Option: zod.z.string().optional(),
+  Locations: pnlArray(checkoutLocationSchema)
+}).transform((p) => ({
+  ...stripUndefined({
+    pickupDate: p.PickupDate,
+    shippingDate: p.ShippingDate,
+    option: p.Option
+  }),
+  locations: p.Locations
+}));
+var warningSchema = zod.z.object({
+  DeliveryDate: pnlDateField,
+  Code: zod.z.string().optional(),
+  Description: zod.z.string().optional(),
+  Options: zod.z.string().optional()
+}).transform(
+  (w) => stripUndefined({
+    deliveryDate: w.DeliveryDate,
+    code: w.Code,
+    description: w.Description,
+    options: w.Options
+  })
+);
+var checkoutResponseSchema = zod.z.object({
+  DeliveryOptions: pnlArray(deliveryOptionSchema),
+  PickupOptions: pnlArray(pickupOptionSchema),
+  Warnings: pnlArray(warningSchema)
+}).transform((r) => ({
+  deliveryOptions: r.DeliveryOptions,
+  pickupOptions: r.PickupOptions,
+  warnings: r.Warnings
+}));
+
+// src/resources/checkout/index.ts
+var asDateTime = (v) => v instanceof Date ? formatDate(v, "datetime") : v;
+var CheckoutResource = class extends BaseResource {
+  // POST /shipment/v1/checkout
+  get(input) {
+    return this.call({
+      operation: "checkoutGet",
+      input: toCheckoutRequestBody(input, asDateTime(input.orderDate)),
+      responseSchema: checkoutResponseSchema
+    });
+  }
+};
+var deliveryDateResponseSchema = zod.z.object({
+  DeliveryDate: pnlDateField,
+  Options: pnlArray(zod.z.string()),
+  Sustainability: sustainabilitySchema.optional()
+}).transform(
+  (r) => stripUndefined({
+    deliveryDate: r.DeliveryDate,
+    options: r.Options.length ? r.Options : void 0,
+    sustainability: r.Sustainability
+  })
+);
+var sentDateResponseSchema = zod.z.object({
+  SentDate: pnlDateField,
+  Options: pnlArray(zod.z.string())
+}).transform(
+  (r) => stripUndefined({
+    sentDate: r.SentDate,
+    options: r.Options.length ? r.Options : void 0
+  })
+);
+
+// src/resources/delivery-date/index.ts
+var WEEKDAYS = [
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+  "Sunday"
+];
+var asDateTime2 = (v) => v instanceof Date ? formatDate(v, "datetime") : v;
+var asDate = (v) => v instanceof Date ? formatDate(v, "date") : v;
+var DeliveryDateResource = class extends BaseResource {
+  // GET /shipment/v2_2/calculate/date/delivery
+  calculate(input) {
+    const query = {
+      ShippingDate: asDateTime2(input.shippingDate),
+      ShippingDuration: input.shippingDuration,
+      CutOffTime: input.cutOffTime,
+      PostalCode: input.postalCode,
+      CountryCode: input.countryCode,
+      Options: input.options.join(","),
+      OriginCountryCode: input.originCountryCode ?? "NL",
+      City: input.city,
+      Street: input.street,
+      HouseNumber: input.houseNumber,
+      HouseNrExt: input.houseNrExt
+    };
+    for (const day3 of WEEKDAYS) {
+      query[`CutOffTime${day3}`] = input[`cutOffTime${day3}`];
+      query[`Available${day3}`] = input[`available${day3}`];
+    }
+    return this.call({
+      operation: "deliveryDateCalculate",
+      query,
+      responseSchema: deliveryDateResponseSchema
+    });
+  }
+  // GET /shipment/v2_2/calculate/date/shipping
+  sentDate(input) {
+    return this.call({
+      operation: "deliveryDateSent",
+      query: {
+        DeliveryDate: asDate(input.deliveryDate),
+        ShippingDuration: input.shippingDuration,
+        PostalCode: input.postalCode,
+        CountryCode: input.countryCode,
+        OriginCountryCode: input.originCountryCode ?? "NL",
+        City: input.city,
+        Street: input.street,
+        HouseNumber: input.houseNumber,
+        HouseNrExt: input.houseNrExt
+      },
+      responseSchema: sentDateResponseSchema
+    });
+  }
+};
+
+// src/constants/enums.ts
+var BarcodeType = ["2S", "3S", "CC", "CP", "CD", "CF", "LA", "RI", "UE"];
+var ShipmentTypeV4 = [
+  "parcel",
+  "letterbox",
+  "packet",
+  "parcelnonstandard",
+  "letter"
+];
+var ReturnShipmentTypeV4 = ["parcel", "letterbox", "packet", "parcelnonstandard"];
+var ReceiverType = ["business", "consumer"];
+var OutputType = ["zpl", "pdf", "gif", "jpg", "png"];
+var ReturnOutputType = ["pdf", "gif", "jpg", "png"];
+var PageOrientation = ["portrait", "landscape"];
+var Resolution = [200, 300, 600];
+var MergeType = ["singlepdf", "pdfa6toa4"];
+var Positioning = ["topleft", "topright", "bottomleft", "bottomright"];
+var PrintMethod = ["consumerPrint", "retailPrint"];
+var LabelType = ["labelinthebox"];
+var ReturnPeriod = [35, 100, 200, 365];
+var ReturnPeriodV4 = [20, 35];
+var Bundle = ["track_trace", "insured", "insured_plus"];
+var Language = ["NL", "FR", "EN"];
+var StatusLanguage = ["NL", "EN", "CN", "DE", "FR"];
+var MinimalAgeCheck = ["16+", "18+"];
+var DeliveryConfirmation = ["signature", "deliverycode"];
+var GuaranteedBefore = ["10:00", "12:00", "17:00"];
+var Duration = ["24hours", "non24hours"];
+var ConsolidationMode = ["none", "bulk"];
+var NetworkType = ["commercial", "postal"];
+var AssociatedDocumentType = ["certificate", "invoice", "license"];
+var CountryCode = ["NL", "BE"];
+var OriginCountryCode = ["NL", "BE"];
+var Currency = ["EUR", "GBP", "USD", "CNY"];
+var LabellingCurrency = ["EUR", "USS"];
+var AddressType = ["01", "02"];
+var ShipmentTypeLegacy = [
+  "Gift",
+  "Documents",
+  "Commercial Goods",
+  "Commercial Sample",
+  "Returned Goods"
+];
+var DeliverydateOption = [
+  "Daytime",
+  "Evening",
+  "Morning",
+  "Noon",
+  "Sunday",
+  "Today",
+  "Afternoon"
+];
+var TimeframeOption = [
+  "Daytime",
+  "Today",
+  "Sameday",
+  "Evening",
+  "Morning",
+  "Noon",
+  "Sunday",
+  "Afternoon"
+];
+var CheckoutOption = [
+  "Daytime",
+  "Evening",
+  "Sunday",
+  "Sameday",
+  "Today",
+  "08:00-10:00",
+  "08:00-12:00",
+  "08:00-17:00",
+  "Pickup"
+];
+var CheckoutWarningOption = [
+  "Daytime",
+  "Evening",
+  "Sameday",
+  "Sunday",
+  "Today",
+  "08:00-10:00",
+  "08:00-12:00",
+  "08:00-17:00",
+  "08:00-09:00",
+  "Pickup"
+];
+var CheckoutCutOffDay = ["00", "01", "02", "03", "04", "05", "06", "07"];
+var CheckoutCutOffType = ["Regular", "Sameday", "Today"];
+var LocationDeliveryOption = ["PG", "PA", "PG_EX"];
+var IGNORED_LOCATION_OPTIONS = ["RETA", "UL", "PU", "DO", "BW", "RT", "BWUL"];
+var SustainabilityCode = ["00", "01", "02", "03"];
+var Service = ["evening"];
+
+// src/resources/location/schema.ts
+var IGNORED = new Set(IGNORED_LOCATION_OPTIONS);
+var addressSchema = zod.z.object({
+  City: zod.z.string().optional(),
+  Countrycode: zod.z.string().optional(),
+  HouseNr: pnlNum().optional(),
+  HouseNrExt: zod.z.string().optional(),
+  Remark: zod.z.string().optional(),
+  Street: zod.z.string().optional(),
+  Zipcode: zod.z.string().optional()
+}).transform(
+  (a) => stripUndefined({
+    city: a.City,
+    countrycode: a.Countrycode,
+    houseNr: a.HouseNr,
+    houseNrExt: a.HouseNrExt,
+    remark: a.Remark,
+    street: a.Street,
+    zipcode: a.Zipcode
+  })
+);
+var day2 = pnlStringWrapped(zod.z.string()).optional();
+var openingHoursSchema = zod.z.object({
+  Monday: day2,
+  Tuesday: day2,
+  Wednesday: day2,
+  Thursday: day2,
+  Friday: day2,
+  Saturday: day2,
+  Sunday: day2
+}).transform(
+  (o) => stripUndefined({
+    monday: o.Monday,
+    tuesday: o.Tuesday,
+    wednesday: o.Wednesday,
+    thursday: o.Thursday,
+    friday: o.Friday,
+    saturday: o.Saturday,
+    sunday: o.Sunday
+  })
+);
+var locationSchema = zod.z.object({
+  Address: addressSchema.optional(),
+  DeliveryOptions: pnlArray(zod.z.string()),
+  Distance: pnlNum().optional(),
+  Latitude: pnlNum().optional(),
+  LocationCode: pnlNum().optional(),
+  Longitude: pnlNum().optional(),
+  Name: zod.z.string().optional(),
+  OpeningHours: openingHoursSchema.optional(),
+  Sustainability: sustainabilitySchema.optional(),
+  PartnerName: zod.z.string().optional(),
+  RetailNetworkID: zod.z.string().optional()
+}).transform((l) => {
+  const deliveryOptions = l.DeliveryOptions.filter((o) => !IGNORED.has(o));
+  return stripUndefined({
+    address: l.Address,
+    deliveryOptions: deliveryOptions.length ? deliveryOptions : void 0,
+    distance: l.Distance,
+    latitude: l.Latitude,
+    locationCode: l.LocationCode,
+    longitude: l.Longitude,
+    name: l.Name,
+    openingHours: l.OpeningHours,
+    sustainability: l.Sustainability,
+    partnerName: l.PartnerName,
+    retailNetworkId: l.RetailNetworkID
+  });
+});
+var locationsResponseSchema = zod.z.object({
+  GetLocationsResult: zod.z.object({ ResponseLocation: pnlArray(locationSchema) }).optional().transform((r) => r?.ResponseLocation ?? [])
+}).transform((r) => ({ locations: r.GetLocationsResult }));
+var locationLookupResponseSchema = zod.z.object({
+  GetLocationsResult: zod.z.object({ ResponseLocation: locationSchema.optional() }).optional().transform((r) => r?.ResponseLocation)
+}).transform((r) => stripUndefined({ location: r.GetLocationsResult }));
+
+// src/resources/location/index.ts
+var asDate2 = (v) => v instanceof Date ? formatDate(v, "date") : v;
+var LocationResource = class extends BaseResource {
+  // GET /shipment/v2_1/locations/nearest
+  nearest(input) {
+    return this.call({
+      operation: "locationNearest",
+      query: {
+        CountryCode: input.countryCode,
+        PostalCode: input.postalCode,
+        City: input.city,
+        Street: input.street,
+        HouseNumber: input.houseNumber,
+        HouseNumberExtension: input.houseNumberExtension,
+        DeliveryDate: asDate2(input.deliveryDate),
+        OpeningTime: input.openingTime,
+        DeliveryOptions: input.deliveryOptions?.join(",")
+      },
+      responseSchema: locationsResponseSchema
+    });
+  }
+  // GET /shipment/v2_1/locations/nearest/geocode
+  nearestByGeocode(input) {
+    return this.call({
+      operation: "locationNearestByGeocode",
+      query: {
+        Latitude: input.latitude,
+        Longitude: input.longitude,
+        CountryCode: input.countryCode,
+        DeliveryDate: asDate2(input.deliveryDate),
+        OpeningTime: input.openingTime,
+        DeliveryOptions: input.deliveryOptions?.join(",")
+      },
+      responseSchema: locationsResponseSchema
+    });
+  }
+  // GET /shipment/v2_1/locations/area
+  area(input) {
+    return this.call({
+      operation: "locationArea",
+      query: {
+        LatitudeNorth: input.latitudeNorth,
+        LongitudeWest: input.longitudeWest,
+        LatitudeSouth: input.latitudeSouth,
+        LongitudeEast: input.longitudeEast,
+        CountryCode: input.countryCode,
+        DeliveryDate: asDate2(input.deliveryDate),
+        OpeningTime: input.openingTime,
+        DeliveryOptions: input.deliveryOptions?.join(",")
+      },
+      responseSchema: locationsResponseSchema
+    });
+  }
+  // GET /shipment/v2_1/locations/lookup
+  lookup(input) {
+    return this.call({
+      operation: "locationLookup",
+      query: { LocationCode: String(input.locationCode) },
+      responseSchema: locationLookupResponseSchema
+    });
+  }
+};
+
+// src/core/base64.ts
+function decodeBase64(b64) {
+  const fromBase64 = Uint8Array.fromBase64;
+  if (fromBase64) return fromBase64(b64);
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+var CONTENT_TYPES = {
+  pdf: "application/pdf",
+  gif: "image/gif",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  zpl: "text/plain"
+};
+function labelContentType(outputType) {
+  return CONTENT_TYPES[outputType.toLowerCase()] ?? "application/octet-stream";
+}
+function toDecodedLabel(base64, outputType) {
+  return { base64, contentType: labelContentType(outputType), bytes: () => decodeBase64(base64) };
+}
+
+// src/resources/shipping/schema.ts
+var isoDate = zod.z.preprocess(
+  (v) => v instanceof Date ? Number.isNaN(v.getTime()) ? v : formatIsoDate(v) : v,
+  zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/)
+);
+var internationalAddressDataSchema = zod.z.object({
+  area: zod.z.string().optional(),
+  buildingName: zod.z.string().optional(),
+  doorCode: zod.z.string().optional(),
+  floor: zod.z.string().optional(),
+  region: zod.z.string().optional()
+});
+var addressV4Schema = zod.z.object({
+  countryIso: zod.z.string(),
+  city: zod.z.string().optional(),
+  companyName: zod.z.string().optional(),
+  departmentName: zod.z.string().optional(),
+  houseNumber: zod.z.string().optional(),
+  houseNumberAddition: zod.z.string().optional(),
+  postalCode: zod.z.string().optional(),
+  street: zod.z.string().optional(),
+  addressLine: zod.z.string().optional(),
+  internationalAddressData: internationalAddressDataSchema.optional()
+});
+var contactV4Schema = zod.z.object({
+  email: zod.z.string().optional(),
+  firstName: zod.z.string().optional(),
+  lastName: zod.z.string().optional(),
+  language: zod.z.enum(Language).optional(),
+  mobileNumber: zod.z.string().optional()
+});
+var receiverV4Schema = zod.z.object({
+  address: addressV4Schema,
+  contact: contactV4Schema.optional(),
+  type: zod.z.enum(ReceiverType).optional()
+});
+var senderV4Schema = zod.z.object({
+  customerNumber: zod.z.string(),
+  customerCode: zod.z.string(),
+  address: addressV4Schema,
+  contact: contactV4Schema.optional(),
+  undeliverableReturnAddress: addressV4Schema.optional()
+});
+var dimensionsSchema = zod.z.object({
+  length: zod.z.number().int().optional(),
+  width: zod.z.number().int().optional(),
+  height: zod.z.number().int().optional(),
+  volume: zod.z.number().int().optional(),
+  weight: zod.z.number().int().optional()
+});
+var customerReferencesSchema = zod.z.object({
+  shipmentReference: zod.z.string().optional(),
+  costCenter: zod.z.string().optional(),
+  returnReference: zod.z.string().optional()
+});
+var itemV4Schema = zod.z.object({
+  barcode: zod.z.string().optional(),
+  dimensions: dimensionsSchema.optional(),
+  customerReferences: customerReferencesSchema.optional()
+});
+var labelSettingsSchema = zod.z.object({
+  outputType: zod.z.enum(OutputType).optional(),
+  pageOrientation: zod.z.enum(PageOrientation).default("portrait"),
+  resolution: zod.z.union([zod.z.literal(200), zod.z.literal(300), zod.z.literal(600)]).default(200),
+  mergeType: zod.z.enum(MergeType).optional(),
+  positioning: zod.z.enum(Positioning).optional()
+});
+var deliveryWindowSchema = zod.z.object({
+  service: zod.z.enum(Service).optional(),
+  guaranteedBefore: zod.z.enum(GuaranteedBefore).optional(),
+  duration: zod.z.enum(Duration).optional()
+});
+var servicesSchema = zod.z.object({
+  insuredValue: zod.z.number().optional(),
+  deliveryWindow: deliveryWindowSchema.optional(),
+  statedAddressOnly: zod.z.boolean().optional(),
+  returnWhenNotHome: zod.z.boolean().optional(),
+  minimalAgeCheck: zod.z.enum(MinimalAgeCheck).optional(),
+  deliveryConfirmation: zod.z.enum(DeliveryConfirmation).optional(),
+  adrLq: zod.z.boolean().optional(),
+  registered: zod.z.boolean().optional()
+});
+var contentSchema = zod.z.object({
+  countryOfOrigin: zod.z.string(),
+  description: zod.z.string(),
+  quantity: zod.z.number().int(),
+  value: zod.z.number(),
+  weight: zod.z.number().int(),
+  hsTariffNumber: zod.z.string().optional()
+});
+var associatedDocumentSchema = zod.z.object({
+  type: zod.z.enum(AssociatedDocumentType),
+  number: zod.z.string()
+});
+var customsV4Schema = zod.z.object({
+  content: zod.z.array(contentSchema),
+  transactionCode: zod.z.string(),
+  currency: zod.z.string(),
+  handleAsNonDeliverable: zod.z.boolean().optional(),
+  associatedDocument: associatedDocumentSchema.optional(),
+  senderIdentification: zod.z.string().optional(),
+  receiverIdentification: zod.z.string().optional(),
+  labelSignature: zod.z.boolean().optional()
+});
+var internationalShipmentDataV4Schema = zod.z.object({
+  pudo: zod.z.boolean().optional(),
+  customs: customsV4Schema.optional(),
+  bundle: zod.z.enum(Bundle).optional()
+});
+var deliveryLocationV4Schema = zod.z.object({
+  pickUpLocationId: zod.z.string().optional(),
+  address: addressV4Schema.optional()
+});
+var returnOptionsV4Schema = zod.z.object({
+  labelType: zod.z.string().optional(),
+  returnPeriod: zod.z.union([zod.z.literal(35), zod.z.literal(100), zod.z.literal(200), zod.z.literal(365)]).optional(),
+  returnAddress: addressV4Schema.optional(),
+  returnBarcode: zod.z.string().optional()
+});
+var shipmentV4BaseShape = {
+  receiver: receiverV4Schema,
+  sender: senderV4Schema,
+  shipmentType: zod.z.enum(ShipmentTypeV4),
+  handOverDate: isoDate.optional(),
+  deliveryLocation: deliveryLocationV4Schema.optional(),
+  returnOptions: returnOptionsV4Schema.optional(),
+  // should match items.length for multi-collo shipments
+  itemCount: zod.z.number().int().default(1),
+  items: zod.z.array(itemV4Schema).optional(),
+  internationalShipmentData: internationalShipmentDataV4Schema.optional(),
+  services: servicesSchema.optional()
+};
+var shipmentV4RequestSchema = zod.z.object({
+  ...shipmentV4BaseShape,
+  labelSettings: labelSettingsSchema.optional()
+});
+var labellingV4RequestSchema = zod.z.object({
+  ...shipmentV4BaseShape,
+  labelSettings: labelSettingsSchema.optional()
+});
+var confirmV4RequestSchema = zod.z.object(shipmentV4BaseShape);
+var labelResponseSchema = zod.z.object({
+  label: zod.z.string().optional(),
+  content: zod.z.string().optional(),
+  outputType: zod.z.string().optional(),
+  labelType: zod.z.string().optional()
+}).transform((l) => {
+  const base64 = l.label ?? l.content ?? "";
+  return {
+    ...toDecodedLabel(base64, l.outputType ?? ""),
+    outputType: l.outputType,
+    labelType: l.labelType
+  };
+});
+var productServiceSchema = zod.z.object({
+  productData: zod.z.string().optional(),
+  // untyped in sdk (List[Any]); doc examples show objects
+  services: zod.z.array(zod.z.record(zod.z.unknown())).optional(),
+  bundles: zod.z.array(zod.z.record(zod.z.unknown())).optional()
+});
+var responseItemSchema = zod.z.object({
+  shipmentReference: zod.z.string().optional(),
+  returnReference: zod.z.string().optional(),
+  barcode: zod.z.string().optional(),
+  returnBarcode: zod.z.string().optional(),
+  preannouncedProduct: zod.z.string().optional(),
+  codingText: zod.z.string().optional(),
+  productService: productServiceSchema.optional(),
+  partnerBarcode: zod.z.string().optional(),
+  partnerId: zod.z.string().optional(),
+  labels: zod.z.array(labelResponseSchema).optional()
+});
+var shipmentPostResponseSchema = zod.z.object({
+  items: zod.z.array(responseItemSchema).default([]),
+  traceId: zod.z.string().optional(),
+  warnings: zod.z.array(zod.z.string()).optional()
+});
+var returnCustomerSchema = zod.z.object({
+  customerNumber: zod.z.string(),
+  customerCode: zod.z.string(),
+  address: addressV4Schema
+});
+var returnReceiverSchema = zod.z.object({
+  customer: returnCustomerSchema.optional(),
+  contact: contactV4Schema.optional()
+});
+var returnSenderSchema = zod.z.object({
+  address: addressV4Schema,
+  contact: contactV4Schema.optional()
+});
+var returnLabelSchema = zod.z.object({
+  outputType: zod.z.enum(OutputType),
+  printMethod: zod.z.enum(PrintMethod),
+  pageOrientation: zod.z.enum(PageOrientation).optional(),
+  resolution: zod.z.union([zod.z.literal(200), zod.z.literal(300), zod.z.literal(600)]).optional()
+});
+var returnDomesticSchema = zod.z.object({
+  returnPeriod: zod.z.union([zod.z.literal(20), zod.z.literal(35)]).optional(),
+  valuableReturn: zod.z.boolean().optional()
+});
+var returnInternationalSchema = zod.z.object({
+  consolidationMode: zod.z.enum(ConsolidationMode).optional(),
+  networkType: zod.z.enum(NetworkType).optional()
+});
+var returnCollectionServiceSchema = zod.z.object({
+  timeWindow: isoDate.optional(),
+  // should match items.length for multi-collo shipments
+  itemCount: zod.z.number().int().default(1)
+});
+var returnOptionsSchema = zod.z.object({
+  domestic: returnDomesticSchema.optional(),
+  international: returnInternationalSchema.optional(),
+  collectionService: returnCollectionServiceSchema.optional()
+});
+var returnItemSchema = zod.z.object({
+  barcode: zod.z.string().optional(),
+  dimensions: dimensionsSchema.optional(),
+  customerReferences: customerReferencesSchema.optional()
+});
+var returnGenerateRequestSchema = zod.z.object({
+  receiver: returnReceiverSchema,
+  sender: returnSenderSchema,
+  labelSettings: returnLabelSchema,
+  shipmentType: zod.z.enum(ReturnShipmentTypeV4),
+  returnOptions: returnOptionsSchema.optional(),
+  items: zod.z.array(returnItemSchema).optional()
+});
+
+// src/resources/return/index.ts
+var ReturnResource = class extends BaseResource {
+  // generate a return label
+  generate(input) {
+    return this.call({
+      operation: "returnGenerate",
+      input,
+      requestSchema: returnGenerateRequestSchema,
+      responseSchema: shipmentPostResponseSchema
+    });
+  }
+};
+var messageTimeStamp = zod.z.preprocess(
+  (v) => v instanceof Date ? formatDate(v, "datetime") : v,
+  zod.z.string()
+);
+var legacyAddressSchema = zod.z.object({
+  addressType: zod.z.custom(),
+  countrycode: zod.z.string(),
+  area: zod.z.string().optional(),
+  buildingname: zod.z.string().optional(),
+  city: zod.z.string().optional(),
+  companyName: zod.z.string().optional(),
+  department: zod.z.string().optional(),
+  doorcode: zod.z.string().optional(),
+  firstName: zod.z.string().optional(),
+  floor: zod.z.string().optional(),
+  houseNr: zod.z.string().optional(),
+  houseNrExt: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  region: zod.z.string().optional(),
+  street: zod.z.string().optional(),
+  streetHouseNrExt: zod.z.string().optional(),
+  zipcode: zod.z.string().optional()
+}).transform(
+  (a) => stripUndefined({
+    AddressType: a.addressType,
+    Countrycode: a.countrycode,
+    Area: a.area,
+    Buildingname: a.buildingname,
+    City: a.city,
+    CompanyName: a.companyName,
+    Department: a.department,
+    Doorcode: a.doorcode,
+    FirstName: a.firstName,
+    Floor: a.floor,
+    HouseNr: a.houseNr,
+    HouseNrExt: a.houseNrExt,
+    Name: a.name,
+    Region: a.region,
+    Street: a.street,
+    StreetHouseNrExt: a.streetHouseNrExt,
+    Zipcode: a.zipcode
+  })
+);
+var legacyContactSchema = zod.z.object({
+  contactType: zod.z.string(),
+  email: zod.z.string().optional(),
+  smsNr: zod.z.string().optional(),
+  telNr: zod.z.string().optional()
+}).transform(
+  (c) => stripUndefined({
+    ContactType: c.contactType,
+    Email: c.email,
+    SMSNr: c.smsNr,
+    TelNr: c.telNr
+  })
+);
+var legacyDimensionSchema = zod.z.object({
+  weight: zod.z.number().int(),
+  height: zod.z.number().int().optional(),
+  length: zod.z.number().int().optional(),
+  volume: zod.z.number().int().optional(),
+  width: zod.z.number().int().optional()
+}).transform(
+  (d) => stripUndefined({
+    Weight: d.weight,
+    Height: d.height,
+    Length: d.length,
+    Volume: d.volume,
+    Width: d.width
+  })
+);
+var legacyAmountSchema = zod.z.object({
+  amountType: zod.z.string(),
+  value: zod.z.number(),
+  accountName: zod.z.string().optional(),
+  bic: zod.z.string().optional(),
+  currency: zod.z.custom().optional(),
+  iban: zod.z.string().optional(),
+  reference: zod.z.string().optional(),
+  transactionNumber: zod.z.string().optional()
+}).transform(
+  (a) => stripUndefined({
+    AmountType: a.amountType,
+    Value: a.value,
+    AccountName: a.accountName,
+    BIC: a.bic,
+    Currency: a.currency,
+    IBAN: a.iban,
+    Reference: a.reference,
+    TransactionNumber: a.transactionNumber
+  })
+);
+var legacyGroupSchema = zod.z.object({
+  groupType: zod.z.string(),
+  mainBarcode: zod.z.string(),
+  groupSequence: zod.z.number().int().optional(),
+  groupCount: zod.z.number().int().optional()
+}).transform(
+  (g) => stripUndefined({
+    GroupType: g.groupType,
+    MainBarcode: g.mainBarcode,
+    GroupSequence: g.groupSequence,
+    GroupCount: g.groupCount
+  })
+);
+var legacyProductOptionSchema = zod.z.object({ characteristic: zod.z.string(), option: zod.z.string() }).transform((p) => ({ Characteristic: p.characteristic, Option: p.option }));
+var legacyCustomsContentSchema = zod.z.object({
+  description: zod.z.string(),
+  quantity: zod.z.number().int(),
+  weight: zod.z.number().int(),
+  value: zod.z.number(),
+  hsTariffNr: zod.z.string().optional(),
+  countryOfOrigin: zod.z.string().optional()
+}).transform(
+  (c) => stripUndefined({
+    Description: c.description,
+    Quantity: c.quantity,
+    Weight: c.weight,
+    Value: c.value,
+    HSTariffNr: c.hsTariffNr,
+    CountryOfOrigin: c.countryOfOrigin
+  })
+);
+var legacyCustomsSchema = zod.z.object({
+  currency: zod.z.custom(),
+  shipmentType: zod.z.custom(),
+  content: zod.z.array(legacyCustomsContentSchema),
+  certificate: zod.z.boolean().optional(),
+  certificateNr: zod.z.string().optional(),
+  license: zod.z.boolean().optional(),
+  licenseNr: zod.z.string().optional(),
+  invoice: zod.z.boolean().optional(),
+  invoiceNr: zod.z.string().optional(),
+  handleAsNonDeliverable: zod.z.boolean().optional(),
+  trustedShipperId: zod.z.string().optional(),
+  importerReferenceCode: zod.z.string().optional(),
+  transactionCode: zod.z.string().optional(),
+  transactionDescription: zod.z.string().optional()
+}).transform(
+  (c) => stripUndefined({
+    Currency: c.currency,
+    ShipmentType: c.shipmentType,
+    Content: c.content,
+    Certificate: c.certificate,
+    CertificateNr: c.certificateNr,
+    License: c.license,
+    LicenseNr: c.licenseNr,
+    Invoice: c.invoice,
+    InvoiceNr: c.invoiceNr,
+    HandleAsNonDeliverable: c.handleAsNonDeliverable,
+    TrustedShipperID: c.trustedShipperId,
+    ImporterReferenceCode: c.importerReferenceCode,
+    TransactionCode: c.transactionCode,
+    TransactionDescription: c.transactionDescription
+  })
+);
+var legacyExtraFieldSchema = zod.z.object({ key: zod.z.string().optional(), value: zod.z.string().optional() }).transform((e2) => stripUndefined({ Key: e2.key, Value: e2.value }));
+var legacyShipmentShape = {
+  addresses: zod.z.array(legacyAddressSchema),
+  barcode: zod.z.string(),
+  dimension: legacyDimensionSchema,
+  productCodeDelivery: zod.z.string(),
+  amounts: zod.z.array(legacyAmountSchema).optional(),
+  codingText: zod.z.string().optional(),
+  collectionTimeStampStart: zod.z.string().optional(),
+  collectionTimeStampEnd: zod.z.string().optional(),
+  contacts: zod.z.array(legacyContactSchema).optional(),
+  content: zod.z.string().optional(),
+  costCenter: zod.z.string().optional(),
+  customerOrderNumber: zod.z.string().optional(),
+  customs: legacyCustomsSchema.optional(),
+  deliveryAddress: zod.z.string().optional(),
+  deliveryDate: zod.z.string().optional(),
+  downPartnerBarcode: zod.z.string().optional(),
+  downPartnerId: zod.z.string().optional(),
+  downPartnerLocation: zod.z.string().optional(),
+  groups: zod.z.array(legacyGroupSchema).optional(),
+  hazardousMaterial: zod.z.string().optional(),
+  productCodeCollect: zod.z.string().optional(),
+  productOptions: zod.z.array(legacyProductOptionSchema).optional(),
+  receiverDateOfBirth: zod.z.string().optional(),
+  reference: zod.z.string().optional(),
+  referenceCollect: zod.z.string().optional(),
+  remark: zod.z.string().optional(),
+  returnBarcode: zod.z.string().optional(),
+  returnReference: zod.z.string().optional(),
+  timeslotId: zod.z.string().optional()
+};
+var toWireShipment = (s) => stripUndefined({
+  Addresses: s.addresses,
+  Barcode: s.barcode,
+  Dimension: s.dimension,
+  ProductCodeDelivery: s.productCodeDelivery,
+  Amounts: s.amounts,
+  CodingText: s.codingText,
+  CollectionTimeStampStart: s.collectionTimeStampStart,
+  CollectionTimeStampEnd: s.collectionTimeStampEnd,
+  Contacts: s.contacts,
+  Content: s.content,
+  CostCenter: s.costCenter,
+  CustomerOrderNumber: s.customerOrderNumber,
+  Customs: s.customs,
+  DeliveryAddress: s.deliveryAddress,
+  DeliveryDate: s.deliveryDate,
+  DownPartnerBarcode: s.downPartnerBarcode,
+  DownPartnerID: s.downPartnerId,
+  DownPartnerLocation: s.downPartnerLocation,
+  Groups: s.groups,
+  HazardousMaterial: s.hazardousMaterial,
+  ProductCodeCollect: s.productCodeCollect,
+  ProductOptions: s.productOptions,
+  ReceiverDateOfBirth: s.receiverDateOfBirth,
+  Reference: s.reference,
+  ReferenceCollect: s.referenceCollect,
+  Remark: s.remark,
+  ReturnBarcode: s.returnBarcode,
+  ReturnReference: s.returnReference,
+  TimeslotID: s.timeslotId
+});
+var legacyLabellingShipmentSchema = zod.z.object({ ...legacyShipmentShape, extraFields: zod.z.array(legacyExtraFieldSchema).optional() }).transform((s) => stripUndefined({ ...toWireShipment(s), ExtraFields: s.extraFields }));
+var legacyCustomerSchema = zod.z.object({
+  customerCode: zod.z.string(),
+  customerNumber: zod.z.string(),
+  address: legacyAddressSchema.optional(),
+  collectionLocation: zod.z.string().optional(),
+  contactPerson: zod.z.string().optional(),
+  email: zod.z.string().optional(),
+  name: zod.z.string().optional()
+}).transform(
+  (c) => stripUndefined({
+    CustomerCode: c.customerCode,
+    CustomerNumber: c.customerNumber,
+    Address: c.address,
+    CollectionLocation: c.collectionLocation,
+    ContactPerson: c.contactPerson,
+    Email: c.email,
+    Name: c.name
+  })
+);
+var legacyLabellingMessageSchema = zod.z.object({
+  messageId: zod.z.string(),
+  messageTimeStamp: messageTimeStamp.optional(),
+  printertype: zod.z.string()
+}).transform(
+  (m) => stripUndefined({
+    MessageID: m.messageId,
+    MessageTimeStamp: m.messageTimeStamp ?? formatDate(/* @__PURE__ */ new Date(), "datetime"),
+    Printertype: m.printertype
+  })
+);
+var labellingRequestSchema = zod.z.object({
+  customer: legacyCustomerSchema,
+  message: legacyLabellingMessageSchema,
+  shipments: zod.z.array(legacyLabellingShipmentSchema),
+  labelSignature: zod.z.boolean().optional()
+}).transform(
+  (r) => stripUndefined({
+    Customer: r.customer,
+    Message: r.message,
+    Shipments: r.shipments,
+    LabelSignature: r.labelSignature
+  })
+);
+var legacyConfirmingMessageSchema = zod.z.object({ messageId: zod.z.string(), messageTimeStamp: messageTimeStamp.optional() }).transform((m) => ({
+  MessageID: m.messageId,
+  MessageTimeStamp: m.messageTimeStamp ?? formatDate(/* @__PURE__ */ new Date(), "datetime")
+}));
+var legacyConfirmingShipmentSchema = zod.z.object(legacyShipmentShape).transform((s) => toWireShipment(s));
+var confirmingRequestSchema = zod.z.object({
+  customer: legacyCustomerSchema,
+  message: legacyConfirmingMessageSchema,
+  shipments: zod.z.array(legacyConfirmingShipmentSchema)
+}).transform((r) => ({ Customer: r.customer, Message: r.message, Shipments: r.shipments }));
+var legacyLabelSchema = zod.z.object({
+  Content: zod.z.string().optional(),
+  Labeltype: zod.z.string().optional(),
+  OutputType: zod.z.string().optional()
+}).transform((l) => {
+  const format = l.OutputType ?? l.Labeltype ?? "";
+  return {
+    ...toDecodedLabel(l.Content ?? "", format),
+    labeltype: l.Labeltype,
+    outputType: l.OutputType
+  };
+});
+var warningSchema2 = zod.z.object({ Code: zod.z.string().optional(), Description: zod.z.string().optional() }).transform((w) => stripUndefined({ code: w.Code, description: w.Description }));
+var errorSchema = zod.z.unknown();
+var labellingResponseShipmentSchema = zod.z.object({
+  ProductCodeDelivery: zod.z.string().optional(),
+  Labels: pnlArray(legacyLabelSchema),
+  Barcode: zod.z.string().optional(),
+  Errors: pnlArray(errorSchema),
+  Warnings: pnlArray(warningSchema2)
+}).transform((s) => ({
+  labels: s.Labels,
+  ...stripUndefined({
+    productCodeDelivery: s.ProductCodeDelivery,
+    barcode: s.Barcode,
+    errors: s.Errors.length ? s.Errors : void 0,
+    warnings: s.Warnings.length ? s.Warnings : void 0
+  })
+}));
+var legacyMergedLabelSchema = zod.z.object({ Barcodes: pnlArray(zod.z.string()), Labels: pnlArray(legacyLabelSchema) }).transform((m) => ({ barcodes: m.Barcodes, labels: m.Labels }));
+var labellingResponseSchema = zod.z.object({
+  MergedLabels: pnlArray(legacyMergedLabelSchema),
+  ResponseShipments: pnlArray(labellingResponseShipmentSchema)
+}).transform((r) => ({
+  responseShipments: r.ResponseShipments,
+  ...r.MergedLabels.length ? { mergedLabels: r.MergedLabels } : {}
+}));
+var confirmingResponseShipmentSchema = zod.z.object({
+  Barcode: zod.z.string().optional(),
+  Errors: pnlArray(errorSchema),
+  Warnings: pnlArray(warningSchema2)
+}).transform(
+  (s) => stripUndefined({
+    barcode: s.Barcode,
+    errors: s.Errors.length ? s.Errors : void 0,
+    warnings: s.Warnings.length ? s.Warnings : void 0
+  })
+);
+var confirmingResponseSchema = zod.z.object({ ResponseShipments: pnlArray(confirmingResponseShipmentSchema) }).transform((r) => ({ responseShipments: r.ResponseShipments }));
+
+// src/resources/shipping/legacy.ts
+var ShippingLegacyResource = class extends BaseResource {
+  // POST /shipment/v2_2/label; confirm query param defaults true
+  label(input, options) {
+    return this.call({
+      operation: "shippingLabelLegacy",
+      query: { confirm: options?.confirm ?? true },
+      input,
+      requestSchema: labellingRequestSchema,
+      responseSchema: labellingResponseSchema
+    });
+  }
+  // POST /shipment/v2/confirm
+  confirm(input) {
+    return this.call({
+      operation: "shippingConfirmLegacy",
+      input,
+      requestSchema: confirmingRequestSchema,
+      responseSchema: confirmingResponseSchema
+    });
+  }
+};
+
+// src/resources/shipping/index.ts
+var ShippingResource = class extends BaseResource {
+  // legacy label/confirm (POST /shipment/v2_2/label, /shipment/v2/confirm)
+  legacy = new ShippingLegacyResource(this.transport);
+  // create + confirm in one call (labelconfirm)
+  create(input) {
+    return this.call({
+      operation: "shippingCreate",
+      input,
+      requestSchema: shipmentV4RequestSchema,
+      responseSchema: shipmentPostResponseSchema
+    });
+  }
+  // generate label without confirming
+  label(input) {
+    return this.call({
+      operation: "shippingLabelV4",
+      input,
+      requestSchema: labellingV4RequestSchema,
+      responseSchema: shipmentPostResponseSchema
+    });
+  }
+  // confirm a previously created shipment
+  confirm(input) {
+    return this.call({
+      operation: "shippingConfirmV4",
+      input,
+      requestSchema: confirmV4RequestSchema,
+      responseSchema: shipmentPostResponseSchema
+    });
+  }
+};
+var timeframeTimeframeSchema = zod.z.object({
+  From: zod.z.string().optional(),
+  To: zod.z.string().optional(),
+  Options: pnlArray(zod.z.string()),
+  Sustainability: sustainabilitySchema.optional()
+}).transform(
+  (t) => stripUndefined({
+    from: t.From,
+    to: t.To,
+    options: t.Options.length ? t.Options : void 0,
+    sustainability: t.Sustainability
+  })
+);
+var timeframeSchema2 = zod.z.object({
+  Date: pnlDateField,
+  Timeframes: zod.z.object({ TimeframeTimeframe: pnlArray(timeframeTimeframeSchema) }).optional().transform((t) => t?.TimeframeTimeframe ?? [])
+}).transform((t) => ({
+  ...stripUndefined({ date: t.Date }),
+  timeframes: t.Timeframes
+}));
+var reasonNoTimeframeSchema = zod.z.object({
+  Code: zod.z.string().optional(),
+  Date: pnlDateField,
+  Description: zod.z.string().optional(),
+  Options: pnlArray(zod.z.string()),
+  Sustainability: sustainabilitySchema.optional()
+}).transform(
+  (r) => stripUndefined({
+    code: r.Code,
+    date: r.Date,
+    description: r.Description,
+    options: r.Options.length ? r.Options : void 0,
+    sustainability: r.Sustainability
+  })
+);
+var timeframeResponseSchema = zod.z.object({
+  Timeframes: zod.z.object({ Timeframe: pnlArray(timeframeSchema2) }).optional().transform((t) => t?.Timeframe ?? []),
+  ReasonNoTimeframes: zod.z.object({ ReasonNoTimeframe: pnlArray(reasonNoTimeframeSchema) }).optional().transform((r) => r?.ReasonNoTimeframe ?? [])
+}).transform((r) => ({
+  timeframes: r.Timeframes,
+  reasonNoTimeframes: r.ReasonNoTimeframes
+}));
+
+// src/resources/timeframe/index.ts
+var asDate3 = (v) => v instanceof Date ? formatDate(v, "date") : v;
+var TimeframeResource = class extends BaseResource {
+  // GET /shipment/v2_1/calculate/timeframes
+  get(input) {
+    return this.call({
+      operation: "timeframeGet",
+      query: {
+        AllowSundaySorting: input.allowSundaySorting,
+        StartDate: asDate3(input.startDate),
+        EndDate: asDate3(input.endDate),
+        CountryCode: input.countryCode,
+        PostalCode: input.postalCode,
+        HouseNumber: input.houseNumber,
+        Options: input.options.join(","),
+        HouseNrExt: input.houseNrExt,
+        City: input.city,
+        Street: input.street
+      },
+      responseSchema: timeframeResponseSchema
+    });
+  }
+};
+var pnlDate = zod.z.string().nullish().transform((v) => {
+  if (v == null) return void 0;
+  try {
+    return parsePnlDate(v);
+  } catch {
+    return v;
+  }
+});
+var customerSchema = zod.z.object({
+  CustomerCode: zod.z.string().optional(),
+  CustomerNumber: zod.z.string().optional(),
+  Name: zod.z.string().optional()
+}).transform(
+  (c) => stripUndefined({
+    customerCode: c.CustomerCode,
+    customerNumber: c.CustomerNumber,
+    name: c.Name
+  })
+);
+var dimensionSchema = zod.z.object({
+  Weight: pnlNum().optional(),
+  Height: pnlNum().optional(),
+  Length: pnlNum().optional(),
+  Width: pnlNum().optional(),
+  Volume: pnlNum().optional()
+}).transform(
+  (d) => stripUndefined({
+    weight: d.Weight,
+    height: d.Height,
+    length: d.Length,
+    width: d.Width,
+    volume: d.Volume
+  })
+);
+var amountSchema = zod.z.object({
+  RemboursBedrag: zod.z.string().optional(),
+  VerzekerdBedrag: zod.z.string().optional()
+}).transform(
+  (a) => stripUndefined({ remboursBedrag: a.RemboursBedrag, verzekerdBedrag: a.VerzekerdBedrag })
+);
+var addressSchema2 = zod.z.object({
+  FirstName: zod.z.string().optional(),
+  LastName: zod.z.string().optional(),
+  CompanyName: zod.z.string().optional(),
+  DepartmentName: zod.z.string().optional(),
+  CountryCode: zod.z.string().optional(),
+  Zipcode: zod.z.string().optional(),
+  Region: zod.z.string().optional(),
+  District: zod.z.string().optional(),
+  City: zod.z.string().optional(),
+  Street: zod.z.string().optional(),
+  HouseNumber: zod.z.string().optional(),
+  HouseNumberSuffix: zod.z.string().optional(),
+  Building: zod.z.string().optional(),
+  Floor: zod.z.string().optional(),
+  Remark: zod.z.string().optional()
+}).transform(
+  (a) => stripUndefined({
+    firstName: a.FirstName,
+    lastName: a.LastName,
+    companyName: a.CompanyName,
+    departmentName: a.DepartmentName,
+    countryCode: a.CountryCode,
+    zipcode: a.Zipcode,
+    region: a.Region,
+    district: a.District,
+    city: a.City,
+    street: a.Street,
+    houseNumber: a.HouseNumber,
+    houseNumberSuffix: a.HouseNumberSuffix,
+    building: a.Building,
+    floor: a.Floor,
+    remark: a.Remark
+  })
+);
+var statusSchema = zod.z.object({
+  TimeStamp: pnlDate,
+  StatusCode: zod.z.string().optional(),
+  StatusDescription: zod.z.string().optional(),
+  PhaseCode: zod.z.string().optional(),
+  PhaseDescription: zod.z.string().optional()
+}).transform(
+  (s) => stripUndefined({
+    timeStamp: s.TimeStamp,
+    statusCode: s.StatusCode,
+    statusDescription: s.StatusDescription,
+    phaseCode: s.PhaseCode,
+    phaseDescription: s.PhaseDescription
+  })
+);
+var eventSchema = zod.z.object({
+  Code: zod.z.string().optional(),
+  Description: zod.z.string().optional(),
+  DestinationLocationCode: zod.z.string().optional(),
+  LocationCode: zod.z.string().optional(),
+  RouteCode: zod.z.string().optional(),
+  RouteNumber: zod.z.string().optional(),
+  TimeStamp: pnlDate
+}).transform(
+  (e2) => stripUndefined({
+    code: e2.Code,
+    description: e2.Description,
+    destinationLocationCode: e2.DestinationLocationCode,
+    locationCode: e2.LocationCode,
+    routeCode: e2.RouteCode,
+    routeNumber: e2.RouteNumber,
+    timeStamp: e2.TimeStamp
+  })
+);
+var expectationSchema = zod.z.object({ ETAFrom: pnlDate, ETATo: pnlDate }).transform((e2) => stripUndefined({ etaFrom: e2.ETAFrom, etaTo: e2.ETATo }));
+var productOptionsSchema = zod.z.object({
+  ProductOption: zod.z.object({
+    OptionCode: zod.z.string().optional(),
+    CharacteristicCode: zod.z.string().optional()
+  }).optional()
+}).transform(
+  (p) => stripUndefined({
+    optionCode: p.ProductOption?.OptionCode,
+    characteristicCode: p.ProductOption?.CharacteristicCode
+  })
+);
+var warningSchema3 = zod.z.object({ Message: zod.z.string().optional(), Code: zod.z.string().optional() }).transform((w) => stripUndefined({ message: w.Message, code: w.Code }));
+var baseShipmentSchema = zod.z.object({
+  MainBarcode: zod.z.string().optional(),
+  Barcode: zod.z.string().optional(),
+  ShipmentAmount: pnlNum().optional(),
+  ShipmentCounter: pnlNum().optional(),
+  Customer: customerSchema.optional(),
+  ProductCode: zod.z.string().optional(),
+  ProductDescription: zod.z.string().optional(),
+  Reference: zod.z.string().optional(),
+  DeliveryDate: pnlDate,
+  Dimension: dimensionSchema.optional(),
+  Address: pnlArray(addressSchema2),
+  ProductOptions: pnlArray(productOptionsSchema),
+  Status: statusSchema.optional()
+});
+var toBaseShipment = (s) => stripUndefined({
+  mainBarcode: s.MainBarcode,
+  barcode: s.Barcode,
+  shipmentAmount: s.ShipmentAmount,
+  shipmentCounter: s.ShipmentCounter,
+  customer: s.Customer,
+  productCode: s.ProductCode,
+  productDescription: s.ProductDescription,
+  reference: s.Reference,
+  deliveryDate: s.DeliveryDate,
+  dimension: s.Dimension,
+  addresses: s.Address.length ? s.Address : void 0,
+  productOptions: s.ProductOptions.length ? s.ProductOptions : void 0,
+  status: s.Status
+});
+var currentStatusShipmentSchema = baseShipmentSchema.transform((s) => toBaseShipment(s));
+var completeStatusShipmentSchema = baseShipmentSchema.extend({
+  Amount: amountSchema.optional(),
+  Event: pnlArray(eventSchema),
+  Expectation: expectationSchema.optional(),
+  OldStatus: pnlArray(statusSchema)
+}).transform(
+  (s) => stripUndefined({
+    ...toBaseShipment(s),
+    amount: s.Amount,
+    events: s.Event.length ? s.Event : void 0,
+    expectation: s.Expectation,
+    oldStatuses: s.OldStatus.length ? s.OldStatus : void 0
+  })
+);
+var shippingStatusResponseSchema = zod.z.object({
+  CurrentStatus: zod.z.object({ Shipment: currentStatusShipmentSchema }).optional(),
+  CompleteStatus: zod.z.object({ Shipment: completeStatusShipmentSchema }).optional(),
+  Warnings: pnlArray(warningSchema3)
+}).transform((r) => ({
+  ...stripUndefined({
+    currentStatus: r.CurrentStatus?.Shipment,
+    completeStatus: r.CompleteStatus?.Shipment
+  }),
+  warnings: r.Warnings
+}));
+var signatureSchema = zod.z.object({
+  Barcode: zod.z.string().optional(),
+  SignatureDate: pnlDate,
+  SignatureImage: zod.z.string().optional()
+}).transform(
+  (s) => stripUndefined({
+    barcode: s.Barcode,
+    signatureDate: s.SignatureDate,
+    signatureImage: s.SignatureImage ? toDecodedLabel(s.SignatureImage, "gif") : void 0
+  })
+);
+var signatureResponseSchema = zod.z.object({
+  Signature: signatureSchema.optional(),
+  // signature Warnings is a single-object wrapper { Warning: {...} }; unwrap to a 1-element array
+  Warnings: zod.z.object({ Warning: pnlArray(warningSchema3) }).optional().transform((w) => w?.Warning ?? [])
+}).transform((r) => ({
+  ...stripUndefined({ signature: r.Signature }),
+  warnings: r.Warnings
+}));
+var updatedShipmentStatusSchema = zod.z.object({
+  Timestamp: pnlDate,
+  StatusCode: zod.z.string().optional(),
+  StatusDescription: zod.z.string().optional(),
+  PhaseCode: zod.z.string().optional(),
+  PhaseDescription: zod.z.string().optional()
+}).transform(
+  (s) => stripUndefined({
+    timestamp: s.Timestamp,
+    statusCode: s.StatusCode,
+    statusDescription: s.StatusDescription,
+    phaseCode: s.PhaseCode,
+    phaseDescription: s.PhaseDescription
+  })
+);
+var updatedShipmentSchema = zod.z.object({
+  Barcode: zod.z.string().optional(),
+  CreationDate: pnlDate,
+  CustomerNumber: zod.z.string().optional(),
+  CustomerCode: zod.z.string().optional(),
+  Status: updatedShipmentStatusSchema.optional()
+}).transform(
+  (s) => stripUndefined({
+    barcode: s.Barcode,
+    creationDate: s.CreationDate,
+    customerNumber: s.CustomerNumber,
+    customerCode: s.CustomerCode,
+    status: s.Status
+  })
+);
+var updatedShipmentsResponseSchema = pnlArray(updatedShipmentSchema);
+
+// src/resources/tracking/index.ts
+var TrackingResource = class extends BaseResource {
+  // GET /shipment/v2/status/barcode/{barcode}
+  byBarcode(barcode, options) {
+    return this.call({
+      operation: "trackingByBarcode",
+      pathParams: { barcode },
+      query: {
+        detail: options?.detail,
+        language: options?.language,
+        maxDays: options?.maxDays
+      },
+      responseSchema: shippingStatusResponseSchema
+    });
+  }
+  // GET /shipment/v2/status/reference/{referenceId}; customerCode + customerNumber required
+  byReference(referenceId, options) {
+    return this.call({
+      operation: "trackingByReference",
+      pathParams: { referenceId },
+      query: {
+        customerCode: options.customerCode,
+        customerNumber: options.customerNumber,
+        detail: options.detail,
+        language: options.language,
+        maxDays: options.maxDays
+      },
+      responseSchema: shippingStatusResponseSchema
+    });
+  }
+  // GET /shipment/v2/status/signature/{barcode}
+  signature(barcode) {
+    return this.call({
+      operation: "trackingSignature",
+      pathParams: { barcode },
+      responseSchema: signatureResponseSchema
+    });
+  }
+  // GET /shipment/v2/status/{customernumber}/updatedshipments; two repeated period params
+  updated(customerNumber, options) {
+    return this.call({
+      operation: "trackingUpdated",
+      pathParams: { customernumber: customerNumber },
+      query: { period: options.period },
+      responseSchema: updatedShipmentsResponseSchema
+    });
+  }
+};
+
+// src/client.ts
+var PostNLClient = class {
+  transport;
+  barcode;
+  shipping;
+  return;
+  tracking;
+  deliveryDate;
+  timeframe;
+  location;
+  checkout;
+  address;
+  constructor(options) {
+    const config = resolveConfig(options);
+    this.transport = new Transport(config);
+    this.barcode = new BarcodeResource(this.transport);
+    this.shipping = new ShippingResource(this.transport);
+    this.return = new ReturnResource(this.transport);
+    this.tracking = new TrackingResource(this.transport);
+    this.deliveryDate = new DeliveryDateResource(this.transport);
+    this.timeframe = new TimeframeResource(this.transport);
+    this.location = new LocationResource(this.transport);
+    this.checkout = new CheckoutResource(this.transport);
+    this.address = new AddressResource(this.transport, config.environment);
+  }
+  // low-level escape hatch for endpoints/params not yet covered
+  async request(args) {
+    const raw = await this.transport.send({
+      family: args.family,
+      method: args.method,
+      path: args.path,
+      pathParams: args.pathParams,
+      query: args.query,
+      body: args.body
+    });
+    return args.schema ? args.schema.parse(raw) : raw;
+  }
+};
+
+// src/constants/product.ts
+var ProductCode = {
+  domesticParcel: "3085",
+  domesticInsured: "3087",
+  easyReturn: "4910"
+};
+
+// src/index.ts
+var version = "0.1.0";
+
+exports.AddressResource = AddressResource;
+exports.AddressType = AddressType;
+exports.AssociatedDocumentType = AssociatedDocumentType;
+exports.BarcodeResource = BarcodeResource;
+exports.BarcodeType = BarcodeType;
+exports.Bundle = Bundle;
+exports.CheckoutCutOffDay = CheckoutCutOffDay;
+exports.CheckoutCutOffType = CheckoutCutOffType;
+exports.CheckoutOption = CheckoutOption;
+exports.CheckoutResource = CheckoutResource;
+exports.CheckoutWarningOption = CheckoutWarningOption;
+exports.ConsolidationMode = ConsolidationMode;
+exports.CountryCode = CountryCode;
+exports.Currency = Currency;
+exports.DeliveryConfirmation = DeliveryConfirmation;
+exports.DeliveryDateResource = DeliveryDateResource;
+exports.DeliverydateOption = DeliverydateOption;
+exports.Duration = Duration;
+exports.GuaranteedBefore = GuaranteedBefore;
+exports.IGNORED_LOCATION_OPTIONS = IGNORED_LOCATION_OPTIONS;
+exports.LabelType = LabelType;
+exports.LabellingCurrency = LabellingCurrency;
+exports.Language = Language;
+exports.LocationDeliveryOption = LocationDeliveryOption;
+exports.LocationResource = LocationResource;
+exports.MergeType = MergeType;
+exports.MinimalAgeCheck = MinimalAgeCheck;
+exports.NetworkType = NetworkType;
+exports.OriginCountryCode = OriginCountryCode;
+exports.OutputType = OutputType;
+exports.PageOrientation = PageOrientation;
+exports.Positioning = Positioning;
+exports.PostNLApiError = PostNLApiError;
+exports.PostNLAuthError = PostNLAuthError;
+exports.PostNLBadRequestError = PostNLBadRequestError;
+exports.PostNLClient = PostNLClient;
+exports.PostNLError = PostNLError;
+exports.PostNLMethodNotAllowedError = PostNLMethodNotAllowedError;
+exports.PostNLRateLimitError = PostNLRateLimitError;
+exports.PostNLServerError = PostNLServerError;
+exports.PostNLTimeoutError = PostNLTimeoutError;
+exports.PostNLValidationError = PostNLValidationError;
+exports.PrintMethod = PrintMethod;
+exports.ProductCode = ProductCode;
+exports.ReceiverType = ReceiverType;
+exports.Resolution = Resolution;
+exports.ReturnOutputType = ReturnOutputType;
+exports.ReturnPeriod = ReturnPeriod;
+exports.ReturnPeriodV4 = ReturnPeriodV4;
+exports.ReturnResource = ReturnResource;
+exports.ReturnShipmentTypeV4 = ReturnShipmentTypeV4;
+exports.Service = Service;
+exports.ShipmentTypeLegacy = ShipmentTypeLegacy;
+exports.ShipmentTypeV4 = ShipmentTypeV4;
+exports.ShippingResource = ShippingResource;
+exports.StatusLanguage = StatusLanguage;
+exports.SustainabilityCode = SustainabilityCode;
+exports.TimeframeOption = TimeframeOption;
+exports.TimeframeResource = TimeframeResource;
+exports.TrackingResource = TrackingResource;
+exports.decodeBase64 = decodeBase64;
+exports.labelContentType = labelContentType;
+exports.parseError = parseError;
+exports.toDecodedLabel = toDecodedLabel;
+exports.version = version;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map