node-autotask 0.26.0 → 0.28.0

package/dist/{chunk-VVQ6NJYZ.js → chunk-SYX6EWMT.js}

@@ -38,10 +38,10 @@ import {
   unwrapItem,
   unwrapItems,
   unwrapOperation
-} from "./chunk-SSUECUVN.js";
+} from "./chunk-IRVZGW5K.js";
 import {
   CAPABILITIES
-} from "./chunk-QXWIQ67O.js";
+} from "./chunk-6EQSXYRW.js";
 
 // src/resources/appointments.ts
 var AppointmentsResource = class extends BaseResource {
@@ -172,6 +172,42 @@ var BillingCodesResource = class extends BaseResource {
   }
 };
 
+// src/resources/billing_item_approval_levels.ts
+var BillingItemApprovalLevelsResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "billing_item_approval_levels",
+      resourcePath: "/V1.0/BillingItemApprovalLevels",
+      deletable: false,
+      udfCapable: false
+    }, pageSize);
+  }
+  /** Query BillingItemApprovalLevel records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every BillingItemApprovalLevel record (the MCP-preferred read; 1000-page guarded). */
+  async queryAll(params) {
+    return this.queryAllItems(params);
+  }
+  /** Count matching records (queryCount envelope unwrapped to a plain number). */
+  async count(params) {
+    return this.countGlobal(params);
+  }
+  /** Get one record by id (item envelope; item: null → NotFoundError). */
+  async get(id) {
+    return this.getGlobal(id);
+  }
+  /** Create a record (OperationResultModel → { id}). `dryRun: true` returns the
+   * pinned envelope (section 19.3) and never issues the create. A 2xx that is not the
+   * specced envelope runs the plan-pinned marker recovery (issue #13 — one bounded read;
+   * `recoverIdFromMarker: false` restores the pre-recovery behaviour). */
+  async create(data, opts = {}) {
+    if (opts.dryRun === true) return this.runCreateDryRun(data);
+    return this.createGlobal(data, opts);
+  }
+};
+
 // src/resources/special/dateWindow.ts
 var DAY_MS = 864e5;
 var DEFAULT_LIMIT = 500;
@@ -1255,6 +1291,82 @@ async function upsertByName(resource, companyName, params, opts, http) {
   return createWithDiscovery(resource, body, owner, caveat, opts);
 }
 
+// src/resources/special/_shared/ticketStatus.ts
+var ASSUMED_CLOSED_STATUS_ID = 5;
+var CLOSED_STATUS_LABELS = ["complete", "completed", "closed", "cancelled", "canceled", "resolved"];
+var OP = "tickets.statusSemantics";
+function picklistOf(fields) {
+  if (!Array.isArray(fields)) return [];
+  const status = fields.find((f) => typeof f?.name === "string" && f.name.toLowerCase() === "status");
+  if (status === void 0 || status.isPickList !== true || !Array.isArray(status.picklistValues)) return [];
+  const out = [];
+  for (const v of status.picklistValues) {
+    const id = Number(v?.value);
+    if (!Number.isSafeInteger(id)) continue;
+    out.push({ id, label: typeof v.label === "string" ? v.label : "" });
+  }
+  return out;
+}
+async function readFields(http, fresh) {
+  const cache = http.fieldCache;
+  const key = "tickets";
+  if (!fresh && cache !== void 0) {
+    const shared = cache.inflight(key, "fields");
+    if (shared !== void 0) return await shared;
+    const hit = cache.get(key, "fields");
+    if (hit !== void 0) return hit;
+  }
+  const res = await http.request({ method: "GET", path: "/V1.0/Tickets/entityInformation/fields", operation: OP, maxRetries: 0 });
+  const fields = res?.fields;
+  if (!Array.isArray(fields)) {
+    throw new AutotaskError("Expected the FieldInformationResultModel envelope { fields: [] }; got a different shape", { code: "INVALID_RESPONSE", category: "server" });
+  }
+  cache?.set(key, "fields", fields);
+  return fields;
+}
+function assumed(excludeStatusIds) {
+  const closedIds = excludeStatusIds === void 0 ? [ASSUMED_CLOSED_STATUS_ID] : [...excludeStatusIds];
+  return {
+    picklist: [],
+    closedIds,
+    source: "assumed",
+    assumedId: ASSUMED_CLOSED_STATUS_ID,
+    note: `closed = status ${closedIds.join(", ")} \u2014 ASSUMED, not read from the tenant: the Tickets status picklist could not be resolved, so the historical id ${ASSUMED_CLOSED_STATUS_ID} stands in (fix: expose the Tickets field catalog to this API user, or pass excludeStatusIds)`
+  };
+}
+async function resolveTicketStatusSemantics(http, opts = {}) {
+  if (opts.excludeStatusIds !== void 0) {
+    const closedIds2 = [...new Set(opts.excludeStatusIds.map((id) => Number(id)))];
+    if (closedIds2.length === 0 || closedIds2.some((id) => !Number.isSafeInteger(id) || id < 1)) {
+      throw new AutotaskConfigError(`excludeStatusIds must be a non-empty list of positive status ids (got ${JSON.stringify(opts.excludeStatusIds)})`, { operation: OP });
+    }
+    return { picklist: [], closedIds: closedIds2, source: "picklist", note: `closed = status ${closedIds2.join(", ")} \u2014 supplied by the caller` };
+  }
+  let fields;
+  try {
+    fields = await readFields(http, opts.fresh === true);
+  } catch (e) {
+    if (e instanceof AutotaskError && e.code === "ABORTED") throw e;
+    return assumed();
+  }
+  const picklist = picklistOf(fields);
+  const closedIds = picklist.filter((v) => CLOSED_STATUS_LABELS.includes(v.label.trim().toLowerCase())).map((v) => v.id);
+  if (closedIds.length === 0) return assumed();
+  const labels = picklist.filter((v) => closedIds.includes(v.id)).map((v) => `${v.id} ${v.label}`).join(", ");
+  return {
+    picklist,
+    closedIds,
+    source: "picklist",
+    note: `closed = status not in [${closedIds.join(", ")}] (${labels}) \u2014 resolved from the tenant's Tickets status picklist`
+  };
+}
+function openStatusFilter(closedIds) {
+  return closedIds.length === 1 ? { field: "status", op: "noteq", value: closedIds[0] } : { field: "status", op: "notIn", value: [...closedIds] };
+}
+function isClosedStatus(status, closedIds) {
+  return typeof status === "number" && closedIds.includes(status);
+}
+
 // src/resources/special/companies/fullProfile.ts
 var FULL_PROFILE_PROJECTABLE_PARTS = ["locations", "contacts", "notes", "projects", "openTickets"];
 var PART_ENTITY = {
@@ -1264,7 +1376,7 @@ var PART_ENTITY = {
   projects: "projects",
   openTickets: "tickets"
 };
-var OPEN_TICKETS_NOTE = "open = status != 5 (Complete) \u2014 the ww29 ticket-status picklist has no Closed value; tickets in any other status count as open";
+var OPEN_TICKETS_NOTE = "open = status != 5 (Complete) \u2014 ASSUMED: the tenant Tickets status picklist could not be read, so id 5 is the fallback closed id; tickets in any other status count as open";
 var PROFILE_PART_LIMIT = 50;
 var LOCATION_LIMIT_MAX = 500;
 function locationLimit(value) {
@@ -1325,6 +1437,8 @@ async function scopedCompanyQuery(http, path, companyID, limit, includeFields) {
   return project(unwrapItems(res).items, includeFields);
 }
 async function readOpenTickets(http, companyID, ticketLimit, includeFields) {
+  const semantics = await resolveTicketStatusSemantics(http);
+  const openLeaf = openStatusFilter(semantics.closedIds);
   const openRows = await (async () => {
     const res = await http.request({
       method: "POST",
@@ -1332,30 +1446,31 @@ async function readOpenTickets(http, companyID, ticketLimit, includeFields) {
       path: "/V1.0/Tickets/query",
       body: {
         MaxRecords: ticketLimit,
-        filter: [{ field: "companyID", op: "eq", value: companyID }, { field: "status", op: "noteq", value: 5 }],
+        filter: [{ field: "companyID", op: "eq", value: companyID }, openLeaf],
         ...includeFields ? { IncludeFields: includeFields } : {}
       },
       operation: "companies.fullProfile"
     });
     return project(unwrapItems(res).items, includeFields);
   })();
+  const closedStatus = { closedIds: semantics.closedIds, source: semantics.source, note: semantics.note };
+  const partNote = semantics.source === "assumed" ? OPEN_TICKETS_NOTE : semantics.note;
   let openTickets = {
     items: openRows,
     capped: openRows.length >= ticketLimit,
     blind: false,
-    note: OPEN_TICKETS_NOTE
+    note: partNote,
+    closedStatus
   };
   if (openRows.length === 0) {
-    const stamp = blindStampFor(BLIND_SURFACE_STAMPS["tickets"]?.query, [
-      { field: "companyID", op: "eq", value: companyID },
-      { field: "status", op: "noteq", value: 5 }
-    ]);
+    const stamp = blindStampFor(BLIND_SURFACE_STAMPS["tickets"]?.query, [{ field: "companyID", op: "eq", value: companyID }, openLeaf]);
     if (stamp !== void 0) {
       openTickets = {
         items: openRows,
         capped: openRows.length >= ticketLimit,
         blind: true,
-        note: `${stamp.note} ${OPEN_TICKETS_NOTE}`,
+        note: `${stamp.note} ${partNote}`,
+        closedStatus,
         blindSurface: stamp
       };
     }
@@ -1553,7 +1668,7 @@ function validateUnbilledWorkOptions(companyId, opts) {
 }
 
 // src/resources/special/companies/unbilledWork.ts
-var OP = "companies.unbilledWork";
+var OP2 = "companies.unbilledWork";
 function capJoinSet(ids2, cap) {
   const sorted = [...new Set(ids2)].sort((a, b) => a - b);
   if (sorted.length <= cap) return { ids: sorted, truncated: false };
@@ -1590,14 +1705,14 @@ async function readCompanyAndParent(resource, id, includeParent) {
 }
 async function readJoinSets(http, companyIds, v) {
   const ticketsCond = [{ field: "companyID", op: "in", value: companyIds }];
-  const ticketsRaw = await boundedPart(http, "/V1.0/Tickets/query", ticketsCond, v.limit, OP);
+  const ticketsRaw = await boundedPart(http, "/V1.0/Tickets/query", ticketsCond, v.limit, OP2);
   const projectsCond = [{ field: "companyID", op: "in", value: companyIds }];
-  const projectsRaw = await boundedPart(http, "/V1.0/Projects/query", projectsCond, v.limit, OP);
+  const projectsRaw = await boundedPart(http, "/V1.0/Projects/query", projectsCond, v.limit, OP2);
   const projectIds = projectsRaw.items.map((p) => num(p.id)).filter((n) => n > 0);
   let taskIds = [];
   let tasksHasMore = false;
   if (projectIds.length > 0) {
-    const tasksRaw = await boundedPart(http, "/V1.0/Tasks/query", [{ field: "projectID", op: "in", value: projectIds }], v.limit, OP);
+    const tasksRaw = await boundedPart(http, "/V1.0/Tasks/query", [{ field: "projectID", op: "in", value: projectIds }], v.limit, OP2);
     taskIds = tasksRaw.items.map((t) => num(t.id)).filter((n) => n > 0);
     tasksHasMore = tasksRaw.hasMore;
   }
@@ -1621,7 +1736,7 @@ async function readBillingPart(http, v, companyIds) {
   }
   const billingFields = resolveFieldsPreset("billing_join", "billing_items");
   const billingIncludeFields = [...billingFields, "id", ...v.includeNotes ? ["description"] : []];
-  const billingRaw = await boundedPart(http, "/V1.0/BillingItems/query", billingConditions, v.limit, OP, billingIncludeFields);
+  const billingRaw = await boundedPart(http, "/V1.0/BillingItems/query", billingConditions, v.limit, OP2, billingIncludeFields);
   let billingItems = billingRaw.items;
   let billingNoteCharsTruncated = 0;
   if (v.includeNotes) {
@@ -1665,7 +1780,7 @@ async function readTimePart(http, v, join) {
     if (v.dateFrom !== void 0) timeConditions.push({ field: "dateWorked", op: "gte", value: v.dateFrom });
     if (v.dateTo !== void 0) timeConditions.push({ field: "dateWorked", op: "lte", value: v.dateTo });
     const timeFields = ["taskID", "ticketID", "hoursWorked", "dateWorked", "id", ...v.includeNotes ? ["summaryNotes"] : []];
-    const raw = await boundedPart(http, "/V1.0/TimeEntries/query", timeConditions, v.limit, OP, timeFields);
+    const raw = await boundedPart(http, "/V1.0/TimeEntries/query", timeConditions, v.limit, OP2, timeFields);
     entries = raw.items;
     let cappedItems = entries;
     let noteCharsTruncated = 0;
@@ -5184,7 +5299,7 @@ function appendWiresNote(wires, note) {
   wires.note = (wires.note ? wires.note + " | " : "") + note;
 }
 function makeFetchCtx(rawHttp, v, contractId, budget) {
-  const OP6 = PROFITABILITY_OP;
+  const OP9 = PROFITABILITY_OP;
   const id = parseIdentifier(contractId, "contractId");
   const idNum = typeof id === "number" ? id : Number(id);
   const wires = { issued: 0, requests: 0, budget };
@@ -5196,19 +5311,19 @@ function makeFetchCtx(rawHttp, v, contractId, budget) {
   } };
   const readPart = (path, conditions, fields) => {
     wires.issued += 1;
-    return degradable(() => boundedPart(http, path, conditions, v.limit, OP6, fields));
+    return degradable(() => boundedPart(http, path, conditions, v.limit, OP9, fields));
   };
   const truncatedMonths = {};
   const windowedPart = async (name, key, path, cond, fields, dateField) => {
     const first = await readPart(path, cond, fields);
     if (first.absent !== void 0 || !first.hasMore) return { part: stampPart(key, first, cond), rows: first.items };
-    const wp = await degradable(() => expandByMonth(http, path, cond, v.limit, OP6, fields, dateField, v.dateFrom, v.dateTo, wires));
+    const wp = await degradable(() => expandByMonth(http, path, cond, v.limit, OP9, fields, dateField, v.dateFrom, v.dateTo, wires));
     if (!("truncatedMonths" in wp)) return { part: stampPart(key, wp, cond), rows: [] };
     const { truncatedMonths: tm, ...part } = wp;
     truncatedMonths[name] = tm;
     return { part, rows: wp.items };
   };
-  return { v, OP: OP6, id, idNum, rawHttp, http, wires, windowOn, readPart, windowedPart, truncatedMonths };
+  return { v, OP: OP9, id, idNum, rawHttp, http, wires, windowOn, readPart, windowedPart, truncatedMonths };
 }
 
 // src/resources/special/contracts/profitability.stages.ts
@@ -7131,6 +7246,34 @@ var InvoicesResource = class extends BaseResource {
   }
 };
 
+// src/resources/invoice_templates.ts
+var InvoiceTemplatesResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "invoice_templates",
+      resourcePath: "/V1.0/InvoiceTemplates",
+      deletable: false,
+      udfCapable: false
+    }, pageSize);
+  }
+  /** Query InvoiceTemplate records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every InvoiceTemplate record (the MCP-preferred read; 1000-page guarded). */
+  async queryAll(params) {
+    return this.queryAllItems(params);
+  }
+  /** Count matching records (queryCount envelope unwrapped to a plain number). */
+  async count(params) {
+    return this.countGlobal(params);
+  }
+  /** Get one record by id (item envelope; item: null → NotFoundError). */
+  async get(id) {
+    return this.getGlobal(id);
+  }
+};
+
 // src/resources/modules.ts
 var ModulesResource = class {
   http;
@@ -7369,6 +7512,159 @@ var OpportunityCategoriesResource = class extends BaseResource {
   }
 };
 
+// src/resources/organizational_level1s.ts
+var OrganizationalLevel1sResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "organizational_level1s",
+      resourcePath: "/V1.0/OrganizationalLevel1s",
+      deletable: false,
+      udfCapable: false,
+      collectionUpdate: true
+      // D1: the spec's item path is GET-only — confirmed updates PUT the collection (id in the body)
+    }, pageSize);
+  }
+  /** Query OrganizationalLevel1 records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every OrganizationalLevel1 record (the MCP-preferred read; 1000-page guarded). */
+  async queryAll(params) {
+    return this.queryAllItems(params);
+  }
+  /** Count matching records (queryCount envelope unwrapped to a plain number). */
+  async count(params) {
+    return this.countGlobal(params);
+  }
+  /** Get one record by id (item envelope; item: null → NotFoundError). */
+  async get(id) {
+    return this.getGlobal(id);
+  }
+  /** Create a record (OperationResultModel → { id}). `dryRun: true` returns the
+   * pinned envelope (section 19.3) and never issues the create. A 2xx that is not the
+   * specced envelope runs the plan-pinned marker recovery (issue #13 — one bounded read;
+   * `recoverIdFromMarker: false` restores the pre-recovery behaviour). */
+  async create(data, opts = {}) {
+    if (opts.dryRun === true) return this.runCreateDryRun(data);
+    return this.createGlobal(data, opts);
+  }
+  /** Update a record (PUT on the COLLECTION — the vendored spec's item path is GET-only; the vendor
+   * keys the record by the id in the body). The vendor validates the FULL model on this route (V2), so a
+   * partial body is merged into the CURRENT record first: one fresh GET (which also serves the
+   * stale-object guard's read) then the collection PUT of the merged model — an explicit null in the
+   * caller body sends null; an omitted field keeps the current value. `raw: true` in the opts bag sends
+   * the body as-is (full model or intentional partial — the compatibility escape hatch; no merge read).
+   * `dryRun: true` returns the pinned envelope whose `data` is the merged body (the exact confirmed
+   * wire) with the best-effort diff, from that same single read; a caller-supplied lastModifiedDate that
+   * mismatches the vendor's current value throws STALE_OBJECT before the mutation. */
+  async update(id, data, opts = {}) {
+    if (opts.dryRun === true) return this.runUpdateDryRun(id, data, opts);
+    return this.updateGlobal(id, data, opts);
+  }
+};
+
+// src/resources/organizational_level2s.ts
+var OrganizationalLevel2sResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "organizational_level2s",
+      resourcePath: "/V1.0/OrganizationalLevel2s",
+      deletable: false,
+      udfCapable: false,
+      collectionUpdate: true
+      // D1: the spec's item path is GET-only — confirmed updates PUT the collection (id in the body)
+    }, pageSize);
+  }
+  /** Query OrganizationalLevel2 records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every OrganizationalLevel2 record (the MCP-preferred read; 1000-page guarded). */
+  async queryAll(params) {
+    return this.queryAllItems(params);
+  }
+  /** Count matching records (queryCount envelope unwrapped to a plain number). */
+  async count(params) {
+    return this.countGlobal(params);
+  }
+  /** Get one record by id (item envelope; item: null → NotFoundError). */
+  async get(id) {
+    return this.getGlobal(id);
+  }
+  /** Create a record (OperationResultModel → { id}). `dryRun: true` returns the
+   * pinned envelope (section 19.3) and never issues the create. A 2xx that is not the
+   * specced envelope runs the plan-pinned marker recovery (issue #13 — one bounded read;
+   * `recoverIdFromMarker: false` restores the pre-recovery behaviour). */
+  async create(data, opts = {}) {
+    if (opts.dryRun === true) return this.runCreateDryRun(data);
+    return this.createGlobal(data, opts);
+  }
+  /** Update a record (PUT on the COLLECTION — the vendored spec's item path is GET-only; the vendor
+   * keys the record by the id in the body). The vendor validates the FULL model on this route (V2), so a
+   * partial body is merged into the CURRENT record first: one fresh GET (which also serves the
+   * stale-object guard's read) then the collection PUT of the merged model — an explicit null in the
+   * caller body sends null; an omitted field keeps the current value. `raw: true` in the opts bag sends
+   * the body as-is (full model or intentional partial — the compatibility escape hatch; no merge read).
+   * `dryRun: true` returns the pinned envelope whose `data` is the merged body (the exact confirmed
+   * wire) with the best-effort diff, from that same single read; a caller-supplied lastModifiedDate that
+   * mismatches the vendor's current value throws STALE_OBJECT before the mutation. */
+  async update(id, data, opts = {}) {
+    if (opts.dryRun === true) return this.runUpdateDryRun(id, data, opts);
+    return this.updateGlobal(id, data, opts);
+  }
+};
+
+// src/resources/organizational_level_associations.ts
+var OrganizationalLevelAssociationsResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "organizational_level_associations",
+      resourcePath: "/V1.0/OrganizationalLevelAssociations",
+      deletable: false,
+      udfCapable: false,
+      collectionUpdate: true
+      // D1: the spec's item path is GET-only — confirmed updates PUT the collection (id in the body)
+    }, pageSize);
+  }
+  /** Query OrganizationalLevelAssociation records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every OrganizationalLevelAssociation record (the MCP-preferred read; 1000-page guarded). */
+  async queryAll(params) {
+    return this.queryAllItems(params);
+  }
+  /** Count matching records (queryCount envelope unwrapped to a plain number). */
+  async count(params) {
+    return this.countGlobal(params);
+  }
+  /** Get one record by id (item envelope; item: null → NotFoundError). */
+  async get(id) {
+    return this.getGlobal(id);
+  }
+  /** Create a record (OperationResultModel → { id}). `dryRun: true` returns the
+   * pinned envelope (section 19.3) and never issues the create. A 2xx that is not the
+   * specced envelope runs the plan-pinned marker recovery (issue #13 — one bounded read;
+   * `recoverIdFromMarker: false` restores the pre-recovery behaviour). */
+  async create(data, opts = {}) {
+    if (opts.dryRun === true) return this.runCreateDryRun(data);
+    return this.createGlobal(data, opts);
+  }
+  /** Update a record (PUT on the COLLECTION — the vendored spec's item path is GET-only; the vendor
+   * keys the record by the id in the body). The vendor validates the FULL model on this route (V2), so a
+   * partial body is merged into the CURRENT record first: one fresh GET (which also serves the
+   * stale-object guard's read) then the collection PUT of the merged model — an explicit null in the
+   * caller body sends null; an omitted field keeps the current value. `raw: true` in the opts bag sends
+   * the body as-is (full model or intentional partial — the compatibility escape hatch; no merge read).
+   * `dryRun: true` returns the pinned envelope whose `data` is the merged body (the exact confirmed
+   * wire) with the best-effort diff, from that same single read; a caller-supplied lastModifiedDate that
+   * mismatches the vendor's current value throws STALE_OBJECT before the mutation. */
+  async update(id, data, opts = {}) {
+    if (opts.dryRun === true) return this.runUpdateDryRun(id, data, opts);
+    return this.updateGlobal(id, data, opts);
+  }
+};
+
 // src/resources/phases.ts
 var PhasesResource = class extends BaseResource {
   constructor(http, pageSize) {
@@ -8807,6 +9103,49 @@ var RolesResource = class extends BaseResource {
   }
 };
 
+// src/resources/sales_orders.ts
+var SalesOrdersResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "sales_orders",
+      resourcePath: "/V1.0/SalesOrders",
+      deletable: false,
+      udfCapable: true,
+      collectionUpdate: true
+      // D1: the spec's item path is GET-only — confirmed updates PUT the collection (id in the body)
+    }, pageSize);
+  }
+  /** Query SalesOrder records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every SalesOrder record (the MCP-preferred read; 1000-page guarded). */
+  async queryAll(params) {
+    return this.queryAllItems(params);
+  }
+  /** Count matching records (queryCount envelope unwrapped to a plain number). */
+  async count(params) {
+    return this.countGlobal(params);
+  }
+  /** Get one record by id (item envelope; item: null → NotFoundError). */
+  async get(id) {
+    return this.getGlobal(id);
+  }
+  /** Update a record (PUT on the COLLECTION — the vendored spec's item path is GET-only; the vendor
+   * keys the record by the id in the body). The vendor validates the FULL model on this route (V2), so a
+   * partial body is merged into the CURRENT record first: one fresh GET (which also serves the
+   * stale-object guard's read) then the collection PUT of the merged model — an explicit null in the
+   * caller body sends null; an omitted field keeps the current value. `raw: true` in the opts bag sends
+   * the body as-is (full model or intentional partial — the compatibility escape hatch; no merge read).
+   * `dryRun: true` returns the pinned envelope whose `data` is the merged body (the exact confirmed
+   * wire) with the best-effort diff, from that same single read; a caller-supplied lastModifiedDate that
+   * mismatches the vendor's current value throws STALE_OBJECT before the mutation. */
+  async update(id, data, opts = {}) {
+    if (opts.dryRun === true) return this.runUpdateDryRun(id, data, opts);
+    return this.updateGlobal(id, data, opts);
+  }
+};
+
 // src/resources/service_calls.ts
 var ServiceCallsResource = class extends BaseResource {
   constructor(http, pageSize) {
@@ -9762,6 +10101,57 @@ var TasksResource = class extends BaseResource {
   }
 };
 
+// src/resources/tax_regions.ts
+var TaxRegionsResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "tax_regions",
+      resourcePath: "/V1.0/TaxRegions",
+      deletable: false,
+      udfCapable: false,
+      collectionUpdate: true
+      // D1: the spec's item path is GET-only — confirmed updates PUT the collection (id in the body)
+    }, pageSize);
+  }
+  /** Query TaxRegion records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every TaxRegion record (the MCP-preferred read; 1000-page guarded). */
+  async queryAll(params) {
+    return this.queryAllItems(params);
+  }
+  /** Count matching records (queryCount envelope unwrapped to a plain number). */
+  async count(params) {
+    return this.countGlobal(params);
+  }
+  /** Get one record by id (item envelope; item: null → NotFoundError). */
+  async get(id) {
+    return this.getGlobal(id);
+  }
+  /** Create a record (OperationResultModel → { id}). `dryRun: true` returns the
+   * pinned envelope (section 19.3) and never issues the create. A 2xx that is not the
+   * specced envelope runs the plan-pinned marker recovery (issue #13 — one bounded read;
+   * `recoverIdFromMarker: false` restores the pre-recovery behaviour). */
+  async create(data, opts = {}) {
+    if (opts.dryRun === true) return this.runCreateDryRun(data);
+    return this.createGlobal(data, opts);
+  }
+  /** Update a record (PUT on the COLLECTION — the vendored spec's item path is GET-only; the vendor
+   * keys the record by the id in the body). The vendor validates the FULL model on this route (V2), so a
+   * partial body is merged into the CURRENT record first: one fresh GET (which also serves the
+   * stale-object guard's read) then the collection PUT of the merged model — an explicit null in the
+   * caller body sends null; an omitted field keeps the current value. `raw: true` in the opts bag sends
+   * the body as-is (full model or intentional partial — the compatibility escape hatch; no merge read).
+   * `dryRun: true` returns the pinned envelope whose `data` is the merged body (the exact confirmed
+   * wire) with the best-effort diff, from that same single read; a caller-supplied lastModifiedDate that
+   * mismatches the vendor's current value throws STALE_OBJECT before the mutation. */
+  async update(id, data, opts = {}) {
+    if (opts.dryRun === true) return this.runUpdateDryRun(id, data, opts);
+    return this.updateGlobal(id, data, opts);
+  }
+};
+
 // src/resources/threshold_information.ts
 var ThresholdInformationResource = class {
   http;
@@ -10123,7 +10513,6 @@ var TicketChangeRequestApprovalsResource = class extends BaseResource {
 // src/resources/special/_shared/move-engine.ts
 import { randomUUID } from "crypto";
 var MOVE_SOURCE_AGE_DEFAULT_DAYS = 14;
-var TICKET_COMPLETE_STATUS = 5;
 var MOVE_EFFECTS_NOTE = "Create then delete: the new record gets a fresh create date and creator; creating/deleting may trigger notifications, SLA and workflow rules the API cannot suppress; vendor acceptance of the create is not validated by a dry run";
 var refuse = (code, message, ids2, operation, extra = {}) => new MoveRefusedError(message, { code, operation, details: { status: "failed", ...ids2, ...extra } });
 async function queryRows(http, resource, filter, operation, retries) {
@@ -10176,11 +10565,19 @@ async function preview(http, spec, sourceId, toTicketId, opts) {
   }
   const target = await readTicket(http, toTicketId, opts.maxRetries, op);
   if (target === null) throw refuse("MOVE_TARGET_MISSING", `${op}: target ticket ${toTicketId} does not exist`, ids2, op);
-  if (target.status === TICKET_COMPLETE_STATUS || target.completedDate !== void 0 && target.completedDate !== null) {
-    throw refuse("MOVE_TARGET_CLOSED", `${op}: target ticket ${toTicketId} is closed (status 5 or completed)`, ids2, op);
+  const closedStatus = await resolveTicketStatusSemantics(http);
+  if (isClosedStatus(target.status, closedStatus.closedIds) || target.completedDate !== void 0 && target.completedDate !== null) {
+    throw refuse(
+      "MOVE_TARGET_CLOSED",
+      `${op}: target ticket ${toTicketId} is closed (status in [${closedStatus.closedIds.join(", ")}] or completed) \u2014 closed ids ${closedStatus.source === "assumed" ? "ASSUMED (the tenant status picklist could not be read)" : "resolved from the tenant Tickets status picklist"}`,
+      ids2,
+      op,
+      { closedStatusIds: closedStatus.closedIds, closedStatusSource: closedStatus.source }
+    );
   }
   const origin = await readTicket(http, sourceTicketId, opts.maxRetries, op);
   const facts = {
+    closedStatus: { closedIds: closedStatus.closedIds, source: closedStatus.source, note: closedStatus.note },
     sourceTicketId,
     sourceCompanyID: origin?.companyID ?? null,
     targetCompanyID: target.companyID ?? null,
@@ -10294,22 +10691,22 @@ function uiLinkFor(http, entity, id) {
 }
 
 // src/resources/special/ticket_charges.ts
-var OP2 = "ticket_charges.moveToTicket";
+var OP3 = "ticket_charges.moveToTicket";
 var COPY = ["name", "description", "chargeType", "billingCodeID", "productID", "unitQuantity", "unitCost", "unitPrice", "datePurchased", "isBillableToCompany", "notes", "purchaseOrderNumber", "internalPurchaseOrderNumber"];
 var CONTRACT_SCOPED = ["contractServiceID", "contractServiceBundleID"];
 async function readCharge(http, id, retries) {
-  const rows = await queryRows(http, "TicketCharges", [{ field: "id", op: "eq", value: id }], OP2, retries);
+  const rows = await queryRows(http, "TicketCharges", [{ field: "id", op: "eq", value: id }], OP3, retries);
   return rows[0] ?? null;
 }
 async function checkSource({ http, source, sourceId, sourceTicketId, toTicketId }) {
   if (source.isBilled === true) {
-    throw refuse("MOVE_BLOCKED_BILLED", `${OP2}: ticket charge ${sourceId} is billed \u2014 move it in the Autotask UI`, { sourceId, toTicketId }, OP2, {
+    throw refuse("MOVE_BLOCKED_BILLED", `${OP3}: ticket charge ${sourceId} is billed \u2014 move it in the Autotask UI`, { sourceId, toTicketId }, OP3, {
       manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "tickets", sourceTicketId), reason: "billed charges are not moved by the API (the ticket link opens its charges)" }
     });
   }
 }
 var SPEC = {
-  operation: OP2,
+  operation: OP3,
   entity: "ticket_charge",
   readSource: readCharge,
   sourceTicketId: (s) => typeof s.ticketID === "number" ? s.ticketID : null,
@@ -11750,6 +12147,121 @@ async function fullContext(resource, id, opts = {}, http) {
   return result;
 }
 
+// src/resources/special/tickets/forResource.ts
+var OP4 = "tickets.forResource";
+var TICKET_CHUNK = 100;
+var LIMIT_DEFAULT = 100;
+var LIMIT_MAX = 500;
+var LINK_READ_CAP = 500;
+var TICKET_FIELDS2 = ["id", "ticketNumber", "title", "status", "assignedResourceID", "companyID"];
+function positiveId(value, name) {
+  const n = typeof value === "string" && /^\d+$/.test(value.trim()) ? Number(value) : value;
+  if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 1) {
+    throw new AutotaskConfigError(`${OP4}: ${name} must be a positive integer id (got ${String(value)})`, { operation: OP4 });
+  }
+  return n;
+}
+async function ticketPage(http, filter, maxRecords, fields) {
+  const res = await http.request({
+    method: "POST",
+    idempotent: true,
+    path: "/V1.0/Tickets/query",
+    body: { MaxRecords: maxRecords, filter, IncludeFields: fields },
+    operation: OP4
+  });
+  const page = unwrapItems(res, OP4);
+  return { rows: page.items, more: page.pageDetails.nextPageUrl !== null };
+}
+async function forResource(_resource, resourceIDIn, http, opts = {}) {
+  if (opts === null || typeof opts !== "object") throw new AutotaskConfigError(`${OP4}: opts must be an object`, { operation: OP4 });
+  const resourceID = positiveId(resourceIDIn, "resourceID");
+  const scope = opts.scope ?? "both";
+  if (scope !== "primary" && scope !== "secondary" && scope !== "both") {
+    throw new AutotaskConfigError(`${OP4}: scope must be 'primary', 'secondary' or 'both' (got ${JSON.stringify(opts.scope)})`, { operation: OP4 });
+  }
+  if (opts.openOnly !== void 0 && typeof opts.openOnly !== "boolean") {
+    throw new AutotaskConfigError(`${OP4}: openOnly must be a boolean`, { operation: OP4 });
+  }
+  const limit = opts.limit === void 0 ? LIMIT_DEFAULT : opts.limit;
+  if (!Number.isInteger(limit) || limit < 1 || limit > LIMIT_MAX) {
+    throw new AutotaskConfigError(`${OP4}: limit must be an integer 1-${LIMIT_MAX} (got ${String(opts.limit)})`, { operation: OP4 });
+  }
+  const includeFields = opts.includeFields ?? [];
+  if (!Array.isArray(includeFields) || includeFields.some((f) => typeof f !== "string" || f.length === 0)) {
+    throw new AutotaskConfigError(`${OP4}: includeFields must be a list of field names`, { operation: OP4 });
+  }
+  const openOnly = opts.openOnly === true;
+  const fields = [.../* @__PURE__ */ new Set([...TICKET_FIELDS2, ...includeFields])];
+  const closed = await resolveTicketStatusSemantics(http, opts.excludeStatusIds === void 0 ? {} : { excludeStatusIds: opts.excludeStatusIds });
+  const closedStatus = { closedIds: closed.closedIds, source: closed.source, note: closed.note };
+  const openLeaf = openOnly ? [openStatusFilter(closed.closedIds)] : [];
+  const linkIds = [];
+  let capped = false;
+  if (scope !== "primary") {
+    const res = await http.request({
+      method: "POST",
+      idempotent: true,
+      path: "/V1.0/TicketSecondaryResources/query",
+      body: { MaxRecords: LINK_READ_CAP, filter: [{ field: "resourceID", op: "eq", value: resourceID }], IncludeFields: ["ticketID"] },
+      operation: OP4
+    });
+    const page = unwrapItems(res, OP4);
+    for (const row of page.items) if (typeof row.ticketID === "number" && !linkIds.includes(row.ticketID)) linkIds.push(row.ticketID);
+    if (page.items.length >= LINK_READ_CAP || page.pageDetails.nextPageUrl !== null) capped = true;
+  }
+  const primary = /* @__PURE__ */ new Map();
+  if (scope !== "secondary") {
+    const page = await ticketPage(http, [{ field: "assignedResourceID", op: "eq", value: resourceID }, ...openLeaf], limit, fields);
+    if (page.more || page.rows.length >= limit) capped = true;
+    for (const t of page.rows) if (typeof t.id === "number") primary.set(t.id, t);
+  }
+  const secondary = /* @__PURE__ */ new Map();
+  const unresolvedIds = [];
+  for (let c = 0; c < linkIds.length; c += TICKET_CHUNK) {
+    const chunk = linkIds.slice(c, c + TICKET_CHUNK);
+    const page = await ticketPage(http, [{ field: "id", op: "in", value: chunk }, ...openLeaf], chunk.length, fields);
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of page.rows) {
+      if (typeof t.id !== "number") continue;
+      secondary.set(t.id, t);
+      seen.add(t.id);
+    }
+    for (const id of chunk) if (!seen.has(id)) unresolvedIds.push(id);
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const [id, t] of primary) merged.set(id, t);
+  for (const [id, t] of secondary) if (!merged.has(id)) merged.set(id, t);
+  let tickets = [...merged.values()];
+  if (openOnly) tickets = tickets.filter((t) => !isClosedStatus(t.status, closed.closedIds));
+  tickets.sort((a, b) => Number(a.id) - Number(b.id));
+  if (tickets.length > limit) {
+    tickets = tickets.slice(0, limit);
+    capped = true;
+  }
+  const openCount = tickets.filter((t) => !isClosedStatus(t.status, closed.closedIds)).length;
+  const primaryIds = [...primary.keys()].sort((a, b) => a - b);
+  const secondaryIds = [...secondary.keys()].sort((a, b) => a - b);
+  const both = primaryIds.filter((id) => secondary.has(id));
+  return {
+    resourceID,
+    scope,
+    openOnly,
+    tickets,
+    primaryIds,
+    secondaryIds,
+    bothIds: both,
+    counts: { primary: primaryIds.length, secondary: secondaryIds.length, both: both.length, open: openCount },
+    capped,
+    unresolvedIds: unresolvedIds.sort((a, b) => a - b),
+    closedStatus
+  };
+}
+
+// src/resources/special/tickets/statusSemantics.ts
+async function statusSemantics(_resource, opts = {}, http) {
+  return resolveTicketStatusSemantics(http, opts);
+}
+
 // src/resources/tickets.ts
 var TicketsResource = class extends BaseResource {
   constructor(http, pageSize) {
@@ -11855,6 +12367,14 @@ var TicketsResource = class extends BaseResource {
   fullContext(id, opts) {
     return fullContext(this, id, opts, this.http);
   }
+  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  statusSemantics(opts) {
+    return statusSemantics(this, opts, this.http);
+  }
+  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  forResource(resourceID, opts) {
+    return forResource(this, resourceID, this.http, opts);
+  }
 };
 
 // src/resources/ticket_webhooks.ts
@@ -11983,12 +12503,12 @@ async function postedDateStatusQuery(_resource, mode, http, opts) {
   return items;
 }
 async function postedWithin(_resource, from, to, http, opts, opLabel = "time_entries.postedWithin") {
-  const OP6 = opLabel;
-  if (opts?.tz !== void 0) validateZone(opts.tz, OP6);
-  const fromB = customRangeDay(from, "from", void 0, OP6);
-  const toB = customRangeDay(to, "to", void 0, OP6);
+  const OP9 = opLabel;
+  if (opts?.tz !== void 0) validateZone(opts.tz, OP9);
+  const fromB = customRangeDay(from, "from", void 0, OP9);
+  const toB = customRangeDay(to, "to", void 0, OP9);
   if (fromB.ms > toB.ms) {
-    throw new AutotaskConfigError(`${OP6}: from (${iso2(fromB.ms)}) must not be after to (${iso2(toB.ms)})`, { operation: OP6 });
+    throw new AutotaskConfigError(`${OP9}: from (${iso2(fromB.ms)}) must not be after to (${iso2(toB.ms)})`, { operation: OP9 });
   }
   const windowToMs = toB.ms + DAY_MS2 - 1;
   const filter = [
@@ -11999,7 +12519,7 @@ async function postedWithin(_resource, from, to, http, opts, opLabel = "time_ent
   else if (opts?.posted === false) filter.push({ field: "postedDate", op: "notExist" });
   if (opts?.ticketID !== void 0) filter.push({ field: "ticketID", op: "eq", value: opts.ticketID });
   if (opts?.resourceID !== void 0) filter.push({ field: "resourceID", op: "eq", value: opts.resourceID });
-  const { items, hasMore } = await queryTimeEntries(_resource, filter, clampWindowLimit(opts?.limit), OP6, http);
+  const { items, hasMore } = await queryTimeEntries(_resource, filter, clampWindowLimit(opts?.limit), OP9, http);
   let postedCount = 0;
   for (const item of items) {
     const postedDate = item.postedDate;
@@ -12209,7 +12729,7 @@ async function resolveCode(http, family, familyLabel2, pinnedId, departments, op
 }
 
 // src/resources/special/time_entries/createForResource.ts
-var OP3 = "time_entries.createForResource";
+var OP5 = "time_entries.createForResource";
 var PARAM_KEYS = /* @__PURE__ */ new Set([
   "internallAllocationCodeID",
   "ticketID",
@@ -12245,30 +12765,30 @@ function validateCreateParams(params) {
   if (pinCount > 1) {
     throw new AutotaskConfigError(
       "createForResource: exactly one linkage pin is honoured (internallAllocationCodeID | ticketID | taskID) \u2014 the vendor gate requires exactly one; pass one pin (or none for the default internal linkage)",
-      { operation: OP3 }
+      { operation: OP5 }
     );
   }
   if (pins.role !== void 0 && pins.code !== void 0) {
     throw new AutotaskConfigError(
       "createForResource: a pinned roleID is only meaningful with the task/ticket linkage (internallAllocationCodeID pins the internal linkage and owns the code) \u2014 drop one",
-      { operation: OP3 }
+      { operation: OP5 }
     );
   }
   if (params.hoursWorked !== void 0 && (typeof params.hoursWorked !== "number" || !Number.isFinite(params.hoursWorked) || params.hoursWorked <= 0)) {
     throw new AutotaskConfigError(
       `createForResource: hoursWorked must be a positive finite number (got ${String(params.hoursWorked)})`,
-      { operation: OP3 }
+      { operation: OP5 }
     );
   }
   return pins;
 }
 async function assertResourceActive(http, rid) {
-  const rec = await fetchItem2(http, `/V1.0/Resources/${rid}`, OP3);
+  const rec = await fetchItem2(http, `/V1.0/Resources/${rid}`, OP5);
   if (rec === null) {
     throw new ResourceInvalidError(`Resource ${rid} was not found \u2014 a time entry cannot attach to a missing resource`, {
       resourceIds: [rid],
       details: { idRefs: [{ entity: "resource", id: rid }] },
-      operation: OP3,
+      operation: OP5,
       category: "not_found",
       suggestedAction: "Resolve the resource id (resources.get / resources.search) and retry."
     });
@@ -12277,7 +12797,7 @@ async function assertResourceActive(http, rid) {
     throw new ResourceInvalidError(`Resource ${rid} is not active (isActive !== true) \u2014 the vendor would reject a time entry for an inactive resource`, {
       resourceIds: [rid],
       details: { idRefs: [{ entity: "resource", id: rid }] },
-      operation: OP3,
+      operation: OP5,
       suggestedAction: "Activate the resource or pick an active one."
     });
   }
@@ -12287,11 +12807,11 @@ async function resolveAllocationCode(http, rid, linkage, pins, departments) {
   const pinnedForCode = pins.code !== void 0 ? pins.code : pins.role;
   let code = null;
   const familiesTried = [];
-  code = await resolveCode(http, familyOf(linkage), familyLabel(familyOf(linkage)), pinnedForCode, departments, OP3);
+  code = await resolveCode(http, familyOf(linkage), familyLabel(familyOf(linkage)), pinnedForCode, departments, OP5);
   familiesTried.push({ family: familyOf(linkage), label: familyLabel(familyOf(linkage)), filters: [{ field: "useType", op: "eq", value: familyOf(linkage) }, { field: "isActive", op: "eq", value: true }] });
   if (code === null && linkage === "task" && pins.role === void 0) {
     usedLinkage = "internal";
-    code = await resolveCode(http, USE_TYPE_INTERNAL, familyLabel(USE_TYPE_INTERNAL), void 0, departments, OP3);
+    code = await resolveCode(http, USE_TYPE_INTERNAL, familyLabel(USE_TYPE_INTERNAL), void 0, departments, OP5);
     familiesTried.push({ family: USE_TYPE_INTERNAL, label: familyLabel(USE_TYPE_INTERNAL), filters: [{ field: "useType", op: "eq", value: USE_TYPE_INTERNAL }, { field: "isActive", op: "eq", value: true }] });
   }
   if (code === null) {
@@ -12301,7 +12821,7 @@ async function resolveAllocationCode(http, rid, linkage, pins, departments) {
         families: familiesTried,
         resourceDepartments: [...departments].sort((a, b) => a - b)
       },
-      { operation: OP3 }
+      { operation: OP5 }
     );
   }
   const resolvedCode = codeInfo(code);
@@ -12340,7 +12860,7 @@ function createDryRun2(http, rid, body, linkage, usedLinkage, resolvedCode) {
   }
   return buildDryRunResult(
     {
-      operation: OP3,
+      operation: OP5,
       method: "POST",
       path: "/V1.0/TimeEntries",
       ids: [rid],
@@ -12382,7 +12902,7 @@ async function createWithAttempts(resource, http, opts, body, defaults, pins, us
       const gate3 = ROLE_REJECTION_PATTERN.test(text);
       if (usedLinkage !== "internal" && gate3) {
         if (!taskRoleFetched && usedLinkage === "task" && pins.task !== void 0) {
-          const task = await fetchItem2(http, `/V1.0/Tasks/${pins.task}`, OP3);
+          const task = await fetchItem2(http, `/V1.0/Tasks/${pins.task}`, OP5);
           taskRoleFetched = true;
           if (task !== null) pushLadder(task.assignedResourceRoleID);
         }
@@ -12408,7 +12928,7 @@ async function createForResource(resource, resourceID, params, opts = {}, http)
   const pins = validateCreateParams(params);
   await assertResourceActive(http, rid);
   const linkage = pins.code !== void 0 ? "internal" : pins.ticket !== void 0 ? "ticket" : pins.task !== void 0 ? "task" : "internal";
-  const roleRows = await resourceRoleRows(http, rid, OP3);
+  const roleRows = await resourceRoleRows(http, rid, OP5);
   const departments = roleRows.departments;
   const { usedLinkage, resolvedCode } = await resolveAllocationCode(http, rid, linkage, pins, departments);
   const defaults = windowDefaults(params);
@@ -12431,12 +12951,12 @@ function discoveryField(err, body, defaults) {
 }
 
 // src/resources/special/time_entries/move.ts
-var OP4 = "time_entries.moveToTicket";
+var OP6 = "time_entries.moveToTicket";
 var COPY2 = ["resourceID", "roleID", "billingCodeID", "dateWorked", "startDateTime", "endDateTime", "hoursWorked", "offsetHours", "summaryNotes", "internalNotes", "isNonBillable", "showOnInvoice"];
 var CONTRACT_SCOPED2 = ["contractID", "contractServiceID", "contractServiceBundleID"];
 async function readTimeEntry(http, id, retries) {
   try {
-    const res = await http.request({ method: "GET", path: `/V1.0/TimeEntries/${id}`, operation: OP4, maxRetries: retries });
+    const res = await http.request({ method: "GET", path: `/V1.0/TimeEntries/${id}`, operation: OP6, maxRetries: retries });
     return res?.item ?? null;
   } catch (e) {
     if (isAutotaskError(e) && (e.httpStatus === 404 || e.code === "NOT_FOUND")) return null;
@@ -12446,27 +12966,27 @@ async function readTimeEntry(http, id, retries) {
 async function checkSource2({ http, source, sourceId, toTicketId, retries }) {
   const ids2 = { sourceId, toTicketId };
   if (source.taskID !== null && source.taskID !== void 0) {
-    throw refuse("MOVE_SOURCE_UNSUPPORTED", `${OP4}: time entry ${sourceId} is on a task \u2014 only ticket time entries are moved`, ids2, OP4);
+    throw refuse("MOVE_SOURCE_UNSUPPORTED", `${OP6}: time entry ${sourceId} is on a task \u2014 only ticket time entries are moved`, ids2, OP6);
   }
   if (source.billingApprovalDateTime || source.billingApprovalResourceID || source.billingApprovalLevelMostRecent) {
-    throw refuse("MOVE_BLOCKED_APPROVED", `${OP4}: time entry ${sourceId} has billing approval set \u2014 move it in the Autotask UI`, ids2, OP4, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "approved entries are not moved by the API" } });
+    throw refuse("MOVE_BLOCKED_APPROVED", `${OP6}: time entry ${sourceId} has billing approval set \u2014 move it in the Autotask UI`, ids2, OP6, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "approved entries are not moved by the API" } });
   }
   let billing;
   try {
-    billing = await queryRows(http, "BillingItems", [{ field: "timeEntryID", op: "eq", value: sourceId }], OP4, retries);
+    billing = await queryRows(http, "BillingItems", [{ field: "timeEntryID", op: "eq", value: sourceId }], OP6, retries);
   } catch {
-    throw refuse("MOVE_BLOCKED_BILLED", `${OP4}: the billing items of time entry ${sourceId} could not be read \u2014 refused (fails closed)`, ids2, OP4, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "billing state unreadable" } });
+    throw refuse("MOVE_BLOCKED_BILLED", `${OP6}: the billing items of time entry ${sourceId} could not be read \u2014 refused (fails closed)`, ids2, OP6, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "billing state unreadable" } });
   }
   if (billing.some((b) => b.invoiceID || b.postedDate)) {
-    throw refuse("MOVE_BLOCKED_BILLED", `${OP4}: time entry ${sourceId} is billed or posted \u2014 move it in the Autotask UI`, ids2, OP4, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "billed entries are not moved by the API" } });
+    throw refuse("MOVE_BLOCKED_BILLED", `${OP6}: time entry ${sourceId} is billed or posted \u2014 move it in the Autotask UI`, ids2, OP6, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "billed entries are not moved by the API" } });
   }
-  const attachments = await queryRows(http, "TimeEntryAttachments", [{ field: "timeEntryID", op: "eq", value: sourceId }], OP4, retries);
+  const attachments = await queryRows(http, "TimeEntryAttachments", [{ field: "timeEntryID", op: "eq", value: sourceId }], OP6, retries);
   if (attachments.length > 0) {
-    throw refuse("MOVE_BLOCKED_ATTACHMENTS", `${OP4}: time entry ${sourceId} has attachments, which a delete would destroy \u2014 move it in the Autotask UI`, ids2, OP4, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "entries with attachments are not moved by the API" } });
+    throw refuse("MOVE_BLOCKED_ATTACHMENTS", `${OP6}: time entry ${sourceId} has attachments, which a delete would destroy \u2014 move it in the Autotask UI`, ids2, OP6, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "entries with attachments are not moved by the API" } });
   }
 }
 var SPEC2 = {
-  operation: OP4,
+  operation: OP6,
   entity: "time_entry",
   readSource: readTimeEntry,
   sourceTicketId: (s) => typeof s.ticketID === "number" ? s.ticketID : null,
@@ -12500,29 +13020,116 @@ function moveToTicket2(_resource, sourceId, toTicketId, opts, http) {
   return runMove(http, SPEC2, sourceId, toTicketId, opts);
 }
 
+// src/resources/special/time_entries/approve.ts
+var OP7 = "time_entries.approve";
+var APPROVAL_LEVELS_PATH = "/V1.0/BillingItemApprovalLevels";
+function toIso(value) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) throw new AutotaskConfigError("time_entries.approve: approvalDateTime is an invalid Date");
+    return value.toISOString();
+  }
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) throw new AutotaskConfigError(`time_entries.approve: approvalDateTime "${value}" is not a parseable date`);
+  return parsed.toISOString();
+}
+function toNumber(value) {
+  return typeof value === "number" ? value : Number(value);
+}
+function sameInstant(a, b) {
+  if (typeof a !== "string" || a === "") return false;
+  const left = new Date(a).getTime();
+  const right = new Date(b).getTime();
+  return !Number.isNaN(left) && left === right;
+}
+async function approve(resource, id, opts = {}, http) {
+  const numericId = toNumber(parseIdentifier(id, "id"));
+  if (opts.approvalLevel !== void 0 && (!Number.isInteger(opts.approvalLevel) || opts.approvalLevel < 1)) {
+    throw new AutotaskConfigError(`time_entries.approve: approvalLevel must be a positive integer (got ${String(opts.approvalLevel)})`);
+  }
+  const approvalLevel = opts.approvalLevel ?? 1;
+  const approvalDateTime = toIso(opts.approvalDateTime ?? /* @__PURE__ */ new Date());
+  const entry = await resource.get(numericId);
+  const approvalResourceID = opts.approvalResourceID === void 0 ? entry.resourceID : toNumber(parseIdentifier(opts.approvalResourceID, "approvalResourceID"));
+  if (approvalResourceID === void 0) {
+    throw new AutotaskConfigError(
+      `time_entries.approve: time entry ${numericId} carries no resourceID and the caller supplied no approvalResourceID \u2014 the vendor requires an approving resource`
+    );
+  }
+  const body = { timeEntryID: numericId, approvalLevel, approvalResourceID, approvalDateTime };
+  if (opts.dryRun === true) {
+    return buildDryRunResult(
+      {
+        operation: OP7,
+        method: "POST",
+        path: APPROVAL_LEVELS_PATH,
+        ids: [numericId],
+        checks: [
+          { name: "input-validation", ok: true },
+          { name: "time-entry-exists", ok: true }
+        ],
+        impact: { affected: 1, scope: "single-record", reversible: false },
+        warnings: [
+          "two calls: POST the BillingItemApprovalLevels record, then PUT the time entry (billingApprovalDateTime + billingApprovalResourceID) \u2014 the vendor sets BillingApprovalLevelMostRecent from the create but not these two fields",
+          "approval is not posting: the API exposes no post action on BillingItems, so the entry stays unposted until a vendor workflow posts it",
+          `approvalResourceID ${approvalResourceID} is not existence-checked by the dry run`
+        ],
+        data: body
+      },
+      { redactPersonalData: http.redactPersonalData }
+    );
+  }
+  const created = await http.request({
+    method: "POST",
+    path: APPROVAL_LEVELS_PATH,
+    body,
+    operation: OP7,
+    maxRetries: opts.maxRetries
+  });
+  const levelId = toNumber(parseIdentifier(unwrapOperation(created, OP7).id, "billingItemApprovalLevelID"));
+  await resource.update(
+    numericId,
+    { billingApprovalDateTime: approvalDateTime, billingApprovalResourceID: approvalResourceID },
+    { maxRetries: opts.maxRetries, lastModifiedDate: opts.lastModifiedDate ?? entry.lastModifiedDateTime }
+  );
+  const fresh = await resource.get(numericId);
+  const persisted = sameInstant(fresh.billingApprovalDateTime, approvalDateTime) && fresh.billingApprovalResourceID === approvalResourceID;
+  return {
+    timeEntryID: numericId,
+    billingItemApprovalLevelID: levelId,
+    approvalLevel,
+    approvalResourceID,
+    approvalDateTime,
+    billingApprovalLevelMostRecent: fresh.billingApprovalLevelMostRecent ?? null,
+    billingApprovalDateTime: fresh.billingApprovalDateTime ?? null,
+    billingApprovalResourceID: fresh.billingApprovalResourceID ?? null,
+    status: persisted ? "approved" : "approval_fields_not_persisted",
+    persisted
+  };
+}
+
 // src/resources/special/time_entries/recentTickets.ts
-var OP5 = "time_entries.recentTickets";
+var OP8 = "time_entries.recentTickets";
 var DAY_MS3 = 864e5;
-var TICKET_CHUNK = 100;
-var TICKET_FIELDS2 = ["id", "ticketNumber", "title", "status", "assignedResourceID", "companyID"];
-function positiveId(value, name) {
+var TICKET_CHUNK2 = 100;
+var TICKET_FIELDS3 = ["id", "ticketNumber", "title", "status", "assignedResourceID", "companyID"];
+function positiveId2(value, name) {
   const n = typeof value === "string" && /^\d+$/.test(value.trim()) ? Number(value) : value;
   if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 1) {
-    throw new AutotaskConfigError(`${OP5}: ${name} must be a positive integer id (got ${String(value)})`, { operation: OP5 });
+    throw new AutotaskConfigError(`${OP8}: ${name} must be a positive integer id (got ${String(value)})`, { operation: OP8 });
   }
   return n;
 }
 async function recentTickets(_resource, from, to, http, opts) {
   if (opts === void 0 || opts === null || typeof opts !== "object") {
-    throw new AutotaskConfigError(`${OP5}: opts { resourceID, companyID?, tz?, limit? } is required`, { operation: OP5 });
+    throw new AutotaskConfigError(`${OP8}: opts { resourceID, companyID?, tz?, limit? } is required`, { operation: OP8 });
   }
-  const resourceID = positiveId(opts.resourceID, "resourceID");
-  const companyID = opts.companyID === void 0 ? void 0 : positiveId(opts.companyID, "companyID");
-  if (opts.tz !== void 0) validateZone(opts.tz, OP5);
-  const fromB = customRangeDay(from, "from", void 0, OP5);
-  const toB = customRangeDay(to, "to", void 0, OP5);
+  const resourceID = positiveId2(opts.resourceID, "resourceID");
+  const companyID = opts.companyID === void 0 ? void 0 : positiveId2(opts.companyID, "companyID");
+  if (opts.tz !== void 0) validateZone(opts.tz, OP8);
+  const fromB = customRangeDay(from, "from", void 0, OP8);
+  const toB = customRangeDay(to, "to", void 0, OP8);
   if (fromB.ms > toB.ms) {
-    throw new AutotaskConfigError(`${OP5}: from (${isoUtc(fromB.ms)}) must not be after to (${isoUtc(toB.ms)})`, { operation: OP5 });
+    throw new AutotaskConfigError(`${OP8}: from (${isoUtc(fromB.ms)}) must not be after to (${isoUtc(toB.ms)})`, { operation: OP8 });
   }
   const windowToMs = toB.ms + DAY_MS3 - 1;
   const { items: entries, hasMore } = await queryTimeEntries(
@@ -12533,7 +13140,7 @@ async function recentTickets(_resource, from, to, http, opts) {
       { field: "resourceID", op: "eq", value: resourceID }
     ],
     clampWindowLimit(opts.limit),
-    OP5,
+    OP8,
     http
   );
   const groups = /* @__PURE__ */ new Map();
@@ -12551,17 +13158,17 @@ async function recentTickets(_resource, from, to, http, opts) {
   }
   const ids2 = [...groups.keys()];
   const tickets = /* @__PURE__ */ new Map();
-  for (let c = 0; c < ids2.length; c += TICKET_CHUNK) {
-    const chunk = ids2.slice(c, c + TICKET_CHUNK);
+  for (let c = 0; c < ids2.length; c += TICKET_CHUNK2) {
+    const chunk = ids2.slice(c, c + TICKET_CHUNK2);
     const filter = [{ field: "id", op: "in", value: chunk }];
     const res = await http.request({
       method: "POST",
       idempotent: true,
       path: "/V1.0/Tickets/query",
-      body: { MaxRecords: TICKET_CHUNK, filter, IncludeFields: TICKET_FIELDS2 },
-      operation: OP5
+      body: { MaxRecords: TICKET_CHUNK2, filter, IncludeFields: TICKET_FIELDS3 },
+      operation: OP8
     });
-    for (const t of unwrapItems(res, OP5).items) if (typeof t.id === "number") tickets.set(t.id, t);
+    for (const t of unwrapItems(res, OP8).items) if (typeof t.id === "number") tickets.set(t.id, t);
   }
   const items = [];
   const unresolvedTicketIDs = [];
@@ -12665,6 +13272,10 @@ var TimeEntriesResource = class extends BaseResource {
     return this.resolveBase(identifier);
   }
   /** Node-parity special op (hand-written in src/resources/special/time_entries.ts). */
+  approve(id, opts = {}) {
+    return approve(this, id, opts, this.http);
+  }
+  /** Node-parity special op (hand-written in src/resources/special/time_entries.ts). */
   createForResource(resourceID, params, opts = {}) {
     return createForResource(this, resourceID, params, opts, this.http);
   }
@@ -12805,7 +13416,7 @@ var TimeEntryAttachmentsResource = class extends BaseResource {
 };
 
 // src/resources/special/time_off_requests.ts
-async function approve(_resource, id, opts = {}, http) {
+async function approve2(_resource, id, opts = {}, http) {
   const numericId = parseIdentifier(id, "id");
   if (opts.dryRun === true) {
     return buildDryRunResult({
@@ -12893,7 +13504,7 @@ var TimeOffRequestsResource = class extends BaseResource {
   }
   /** Node-parity special op (hand-written in src/resources/special/time_off_requests.ts). */
   approve(id, opts = {}) {
-    return approve(this, id, opts, this.http);
+    return approve2(this, id, opts, this.http);
   }
   /** Node-parity special op (hand-written in src/resources/special/time_off_requests.ts). */
   reject(id, reason, opts = {}) {
@@ -12965,6 +13576,7 @@ export {
   AppointmentsResource,
   AuthenticateResource,
   BillingCodesResource,
+  BillingItemApprovalLevelsResource,
   BillingItemsResource,
   ChangeRequestLinksResource,
   ChecklistLibrariesResource,
@@ -13024,11 +13636,15 @@ export {
   HolidaysResource,
   InventoryProductsResource,
   InvoicesResource,
+  InvoiceTemplatesResource,
   ModulesResource,
   NotificationHistoryResource,
   OpportunitiesResource,
   OpportunityAttachmentsResource,
   OpportunityCategoriesResource,
+  OrganizationalLevel1sResource,
+  OrganizationalLevel2sResource,
+  OrganizationalLevelAssociationsResource,
   PhasesResource,
   ProductsResource,
   ProductVendorsResource,
@@ -13051,6 +13667,7 @@ export {
   ResourceTimeOffApproversResource,
   ResourceTimeOffBalancesResource,
   RolesResource,
+  SalesOrdersResource,
   ServiceCallsResource,
   ServiceCallTaskResourcesResource,
   ServiceCallTasksResource,
@@ -13068,6 +13685,7 @@ export {
   TagsResource,
   TaskSecondaryResourcesResource,
   TasksResource,
+  TaxRegionsResource,
   ThresholdInformationResource,
   TicketAdditionalConfigurationItemsResource,
   TicketAdditionalContactsResource,