node-autotask 0.43.0 → 0.45.0

package/dist/{chunk-KTEDPS4X.js → chunk-O4PIPUS4.js}

@@ -3,37 +3,47 @@ import {
   AutotaskError,
   BaseResource,
   ConflictError,
+  FETCH_BY_IDS_CHUNK_SIZE,
+  IN_FILTER_CAP,
+  MoveRefusedError,
   NotFoundError,
   RELATIONSHIP_MAP,
+  ResolutionError,
+  ResponseRejectedError,
   StaleObjectError,
   TICKET_LABEL_FIELDS,
   addLabelSibling,
   addNameSibling,
+  budgetExceededError,
   buildDryRunResult,
+  buildUiLink,
+  clientOf,
+  compositePart,
+  compositePartLimit,
   createNamePlan,
   cursorToPath,
-  formatVendorDetail,
+  invokeRead,
   isAutotaskError,
   isClosedStatus,
+  makeCallBudget,
   mergePartialBody,
+  numericIds,
   openStatusFilter,
+  openTicketsOfPart,
   parseIdentifier,
   parseVendorErrors,
-  queryRows,
-  refuse,
   resolveCompositeNames,
   resolveLineOfBusinessChain,
   resolveTicketStatusSemantics,
-  runMove,
-  uiLinkFor,
   unwrapItem,
   unwrapItems,
   unwrapOperation,
+  unwrapQueryCount,
   vendorId
-} from "./chunk-Q23JULNN.js";
+} from "./chunk-NSW7JPVS.js";
 import {
   CAPABILITIES
-} from "./chunk-JY2BWYXY.js";
+} from "./chunk-ASMCTZO2.js";
 
 // src/resources/appointments.ts
 var AppointmentsResource = class extends BaseResource {
@@ -120,6 +130,50 @@ var AuthenticateResource = class {
   }
 };
 
+// src/resources/billing_codes.ts
+var BillingCodesResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "billing_codes",
+      resourcePath: "/V1.0/BillingCodes",
+      deletable: false,
+      udfCapable: false,
+      searchFields: ["name"]
+    }, pageSize);
+  }
+  /** Query BillingCode records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every BillingCode 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). `fresh: true` bypasses the read-cache lookup and refreshes the entry (issue #250). */
+  async get(id, opts = {}) {
+    return this.getGlobal(id, opts?.fresh === true);
+  }
+  /** Resolve a BillingCode from a numeric id (or, where the vendor indexes a primary text field,
+   * from an exact match on name). A numeric id miss throws NOT_FOUND; a complete
+   * non-match returns null; ambiguity throws RESOLUTION_AMBIGUOUS (candidate ids) and a
+   * cap-tripped bounded client scan throws RESOLUTION_TRUNCATED (never a silent null).
+   * The compact shape is the structural alias of the full record; `expand: true` is the
+   * type-level escape hatch. */
+  async resolve(identifier, opts = {}) {
+    void opts;
+    return this.resolveBase(identifier);
+  }
+  /** Search BillingCode records: bounded contains on name (no vendor free-text search exists);
+   * limit defaults to 25, max 500. */
+  async search(query, opts) {
+    return this.searchBase(query, { limit: opts?.limit });
+  }
+};
+
 // src/resources/billing_item_approval_levels.ts
 var BillingItemApprovalLevelsResource = class extends BaseResource {
   constructor(http, pageSize) {
@@ -1096,7 +1150,8 @@ async function fetchRecord(http, path, label, readOpts) {
   }
   return body.item;
 }
-async function moveConfigurationItem(_resource, sourceId, opts, http) {
+async function moveConfigurationItem(_resource, sourceId, opts) {
+  const http = _resource.http;
   const numericSource = parseIdentifier(sourceId, "sourceId");
   if (opts?.destinationCompanyId === void 0) {
     throw new AutotaskConfigError("moveConfigurationItem: destinationCompanyId is required");
@@ -1205,7 +1260,8 @@ async function ciScopedQuery(http, path, itemID, limit) {
   });
   return unwrapItems(res).items;
 }
-async function profile(resource, id, opts = {}, http) {
+async function profile(resource, id, opts = {}) {
+  const http = resource.http;
   const noteLimit = profilePartLimit(opts.noteLimit, "noteLimit");
   const relatedLimit = profilePartLimit(opts.relatedLimit, "relatedLimit");
   const ci = await resource.get(id);
@@ -1333,11 +1389,11 @@ var ConfigurationItemsResource = class extends BaseResource {
   }
   /** Node-parity special op (hand-written in src/resources/special/configuration_items.ts). */
   moveConfigurationItem(sourceId, opts) {
-    return moveConfigurationItem(this, sourceId, opts, this.http);
+    return moveConfigurationItem(this, sourceId, opts);
   }
   /** Node-parity special op (hand-written in src/resources/special/configuration_items.ts). */
   profile(id, opts) {
-    return profile(this, id, opts, this.http);
+    return profile(this, id, opts);
   }
 };
 
@@ -1691,7 +1747,8 @@ async function fetchRecord2(http, path, label, readOpts) {
   }
   return body.item;
 }
-async function moveToCompany(_resource, sourceContactId, destinationCompanyId, opts = {}, http) {
+async function moveToCompany(_resource, sourceContactId, destinationCompanyId, opts = {}) {
+  const http = _resource.http;
   const sourceId = parseIdentifier(sourceContactId, "sourceContactId");
   const destId = parseIdentifier(destinationCompanyId, "destinationCompanyId");
   const source = await fetchRecord2(http, `/V1.0/Contacts/${sourceId}`, `Contact ${sourceId}`, { maxRetries: opts.maxRetries });
@@ -1781,153 +1838,28 @@ async function moveToCompany(_resource, sourceContactId, destinationCompanyId, o
   }
   return { sourceId, newId, destinationCompanyId: destId, created: true, sourceDeleted };
 }
-var OP_UPSERT_EMAIL = "contacts.upsertByEmail";
-var UPSERT_MAX_DISCOVERY_MERGES = 3;
-var EMAIL_SHAPE = /^.+@.+/;
-var SAFE_CONTACT_CREATE_DEFAULTS = {};
-var DEDUP_LIMIT = 10;
-var CompanyNotFoundError = class extends AutotaskError {
-  constructor(message, options = {}) {
-    super(message, {
-      code: "COMPANY_NOT_FOUND",
-      category: "not_found",
-      suggestedAction: "Resolve the company id (companies.get on a known id, or a ticket contactID/companyID via tickets.fullContext) and retry.",
-      ...options
-    });
-    this.name = "CompanyNotFoundError";
-  }
-};
-var ContactCreateFailedError = class extends AutotaskError {
-  /** The vendor-named fields (empty when the 500 body named nothing parseable). */
-  vendorFields;
-  constructor(message, vendorFields, options = {}) {
-    super(message, { code: "CONTACT_CREATE_FAILED", category: "validation", ...options });
-    this.name = "ContactCreateFailedError";
-    this.vendorFields = vendorFields;
-  }
-};
-async function upsertByEmail(resource, companyID, email, extra, opts, http) {
-  const cid = parseIdentifier(companyID, "companyID");
-  if (typeof email !== "string" || !EMAIL_SHAPE.test(email)) {
-    throw new AutotaskConfigError(
-      `upsertByEmail: email must be a non-empty string with the @ shape (a non-empty local part + a non-empty domain; got ${JSON.stringify(email)})`,
-      { operation: OP_UPSERT_EMAIL }
-    );
-  }
-  if (extra !== void 0) {
-    if (extra.isActive !== void 0 && typeof extra.isActive !== "boolean" && extra.isActive !== 0 && extra.isActive !== 1) {
-      throw new AutotaskConfigError(
-        `upsertByEmail: extra.isActive must be a boolean (mapped to the zone-correct number 1/0) or a raw 0/1 number (got ${String(extra.isActive)})`,
-        { operation: OP_UPSERT_EMAIL }
-      );
-    }
-    if (extra.firstName !== void 0 && (typeof extra.firstName !== "string" || extra.firstName === "")) {
-      throw new AutotaskConfigError("upsertByEmail: extra.firstName must be a non-empty string (or omitted \u2014 the node defaults it to the email local-part)", { operation: OP_UPSERT_EMAIL });
-    }
-    if (extra.lastName !== void 0 && typeof extra.lastName !== "string") {
-      throw new AutotaskConfigError("upsertByEmail: extra.lastName must be a string (or omitted \u2014 the node defaults it to the non-empty neutral value Unknown)", { operation: OP_UPSERT_EMAIL });
-    }
-  }
-  const parentRes = await http.request({ method: "GET", path: `/V1.0/Companies/${cid}`, operation: OP_UPSERT_EMAIL, maxRetries: opts.maxRetries });
-  const parentBody = parentRes;
-  if (parentBody === null || !("item" in parentBody) || parentBody.item === null || parentBody.item === void 0) {
-    throw new CompanyNotFoundError(
-      `upsertByEmail: company ${cid} was not found (companies.get returned item: null \u2014 the companies count/query surface is blind to this API user; get is the authority)`,
-      { resourceIds: [cid], details: { idRefs: [{ entity: "company", id: cid }] }, operation: OP_UPSERT_EMAIL }
-    );
-  }
-  const q = await resource.queryBounded({
-    filter: [
-      { field: "emailAddress", op: "eq", value: email },
-      { field: "companyID", op: "eq", value: cid }
-    ],
-    limit: DEDUP_LIMIT
-  });
-  const match = q.items[0];
-  if (match !== void 0) {
-    if (opts.dryRun === true) {
-      return buildDryRunResult(
-        {
-          operation: OP_UPSERT_EMAIL,
-          method: "POST",
-          path: `/V1.0/Companies/${cid}/Contacts`,
-          ids: [cid],
-          checks: [
-            { name: "input-validation", ok: true },
-            { name: "parent-exists", ok: true },
-            { name: "duplicate-detection", ok: true }
-          ],
-          impact: { affected: 0, scope: "no write \u2014 the contact already exists (dedup match; the create is skipped)", reversible: true },
-          warnings: [`EXISTS: a contact with the address is already on company ${cid} (id ${Number(match.id)}) \u2014 the apply would skip the create (zero mutating wire).`],
-          data: { reason: "EXISTS", id: Number(match.id) }
-        },
-        { redactPersonalData: http.redactPersonalData }
-      );
-    }
-    return { id: Number(match.id), created: false, existing: match };
-  }
-  const localPart = email.split("@")[0];
-  const isActive = extra?.isActive === void 0 ? true : extra.isActive;
-  const body = {
-    emailAddress: email,
-    companyID: cid,
-    firstName: extra?.firstName ?? localPart,
-    lastName: extra?.lastName ?? "Unknown",
-    isActive: typeof isActive === "boolean" ? isActive ? 1 : 0 : isActive
-  };
-  if (opts.dryRun === true) {
-    return buildDryRunResult(
-      {
-        operation: OP_UPSERT_EMAIL,
-        method: "POST",
-        path: `/V1.0/Companies/${cid}/Contacts`,
-        ids: [cid],
-        checks: [
-          { name: "input-validation", ok: true },
-          { name: "parent-exists", ok: true },
-          { name: "duplicate-detection", ok: true }
-        ],
-        impact: { affected: 1, scope: "single-record", reversible: true },
-        data: body
-      },
-      { redactPersonalData: http.redactPersonalData }
-    );
-  }
-  let merges = 0;
-  for (; ; ) {
-    try {
-      const created = await resource.create(cid, body, { maxRetries: opts.maxRetries });
-      return { id: created.id, created: true };
-    } catch (err) {
-      if (!isAutotaskError(err) || err.vendorError === void 0) throw err;
-      const named = (parseVendorErrors(err.vendorError) ?? []).map((e) => e.field).filter((f) => f !== void 0);
-      const seen = /* @__PURE__ */ new Set();
-      const unique = [...named].filter((f) => seen.has(f) ? false : (seen.add(f), true));
-      const hasDefault = unique.some((f) => SAFE_CONTACT_CREATE_DEFAULTS[f] !== void 0);
-      if (hasDefault && merges < UPSERT_MAX_DISCOVERY_MERGES) {
-        for (const f of unique) {
-          if (body[f] === void 0 && SAFE_CONTACT_CREATE_DEFAULTS[f] !== void 0) {
-            body[f] = SAFE_CONTACT_CREATE_DEFAULTS[f];
-            merges += 1;
-            break;
-          }
-        }
-        continue;
-      }
-      const detail = formatVendorDetail(err.vendorError);
-      throw new ContactCreateFailedError(
-        `upsertByEmail: the vendor rejected the contact create${unique.length > 0 ? ` naming field(s) ${unique.join(", ")}` : ""} (no proven-safe default \u2014 the required set is fully filled by the node)${detail ? ` \u2014 ${detail}` : ""}`,
-        unique,
-        {
-          operation: OP_UPSERT_EMAIL,
-          httpStatus: err.httpStatus,
-          vendorError: err.vendorError,
-          resourceIds: [cid],
-          details: { idRefs: [{ entity: "company", id: cid }] }
-        }
-      );
-    }
-  }
+var FULL_PROFILE_OP = "contacts.fullProfile";
+async function fullProfile(resource, id, opts = {}) {
+  const client = clientOf(resource, FULL_PROFILE_OP);
+  const ticketLimit = compositePartLimit(opts.ticketLimit, "ticketLimit", FULL_PROFILE_OP);
+  const contactId = parseIdentifier(id, "id");
+  const envelope = await invokeRead(client, "contacts.query", [
+    { filter: [{ field: "id", op: "eq", value: contactId }], limit: 1 }
+  ]);
+  const row = (envelope.items ?? [])[0];
+  if (row === void 0) {
+    throw new NotFoundError(`Contact ${contactId} not found`, { operation: "contacts.get", httpStatus: 404 });
+  }
+  const fk = typeof row.companyID === "number" && row.companyID > 0 ? row.companyID : null;
+  const root = fk === null ? row : await invokeRead(client, "contacts.get", [fk, contactId]);
+  const company = fk === null ? { value: null, absent: "NO_FK" } : await compositePart(client, "companies.get", [fk]);
+  const openTickets = await openTicketsOfPart(
+    client,
+    "contactID",
+    contactId,
+    ticketLimit
+  );
+  return { root, parts: { company, open_tickets: openTickets } };
 }
 
 // src/resources/contacts.ts
@@ -2014,11 +1946,11 @@ var ContactsResource = class extends BaseResource {
   }
   /** Node-parity special op (hand-written in src/resources/special/contacts.ts). */
   moveToCompany(sourceContactId, destinationCompanyId, opts = {}) {
-    return moveToCompany(this, sourceContactId, destinationCompanyId, opts, this.http);
+    return moveToCompany(this, sourceContactId, destinationCompanyId, opts);
   }
   /** Node-parity special op (hand-written in src/resources/special/contacts.ts). */
-  upsertByEmail(companyID, email, extra, opts = {}) {
-    return upsertByEmail(this, companyID, email, extra, opts, this.http);
+  fullProfile(id, opts) {
+    return fullProfile(this, id, opts);
   }
 };
 
@@ -3861,7 +3793,8 @@ var PATH_SUFFIX = {
   remove: "StockedItemsRemove",
   transfer: "StockedItemsTransfer"
 };
-async function stockedItems(_resource, kind, parentId, data, opts = {}, http) {
+async function stockedItems(_resource, kind, parentId, data, opts = {}) {
+  const http = _resource.http;
   const numericParent = parseIdentifier(parentId, "parentId");
   const suffix = PATH_SUFFIX[kind];
   if (opts.dryRun === true) {
@@ -3954,15 +3887,15 @@ var InventoryProductsResource = class extends BaseResource {
   }
   /** Node-parity special op (hand-written in src/resources/special/inventory_products.ts). */
   stockedItemsAdd(parentId, data, opts = {}) {
-    return stockedItems(this, "add", parentId, data, opts, this.http);
+    return stockedItems(this, "add", parentId, data, opts);
   }
   /** Node-parity special op (hand-written in src/resources/special/inventory_products.ts). */
   stockedItemsRemove(parentId, data, opts = {}) {
-    return stockedItems(this, "remove", parentId, data, opts, this.http);
+    return stockedItems(this, "remove", parentId, data, opts);
   }
   /** Node-parity special op (hand-written in src/resources/special/inventory_products.ts). */
   stockedItemsTransfer(parentId, data, opts = {}) {
-    return stockedItems(this, "transfer", parentId, data, opts, this.http);
+    return stockedItems(this, "transfer", parentId, data, opts);
   }
 };
 
@@ -5000,6 +4933,19 @@ var QuoteLocationsResource = class extends BaseResource {
   }
 };
 
+// src/resources/special/quotes.ts
+var OP = "quotes.withItems";
+async function withItems(resource, id, opts = {}) {
+  const client = clientOf(resource, OP);
+  const itemLimit = compositePartLimit(opts.itemLimit, "itemLimit", OP);
+  const quoteId = parseIdentifier(id, "id");
+  const root = await invokeRead(client, "quotes.get", [quoteId]);
+  const items = await compositePart(client, "quote_items.query", [
+    { filter: [{ field: "quoteID", op: "eq", value: quoteId }], limit: itemLimit }
+  ]);
+  return { root, parts: { items } };
+}
+
 // src/resources/quotes.ts
 var QuotesResource = class extends BaseResource {
   constructor(http, pageSize) {
@@ -5065,6 +5011,10 @@ var QuotesResource = class extends BaseResource {
   async search(query, opts) {
     return this.searchBase(query, { limit: opts?.limit });
   }
+  /** Node-parity special op (hand-written in src/resources/special/quotes.ts). */
+  withItems(id, opts) {
+    return withItems(this, id, opts);
+  }
 };
 
 // src/resources/quote_templates.ts
@@ -5263,8 +5213,152 @@ var ResourceSkillsResource = class extends BaseResource {
   }
 };
 
+// src/resources/special/resources.ts
+async function whoAmI(_resource, userName) {
+  const http = _resource.http;
+  const user = userName.trim();
+  if (user === "") throw new AutotaskConfigError("whoAmI: the configured UserName is empty");
+  const value = user.includes("@") ? user.split("@")[0] ?? "" : user;
+  const res = await http.request({
+    method: "POST",
+    idempotent: true,
+    path: "/V1.0/Resources/query",
+    body: { MaxRecords: 2, filter: [{ field: "userName", op: "eq", value }] },
+    operation: "resources.whoAmI"
+  });
+  const matches = unwrapItems(res).items;
+  if (matches.length === 0) return null;
+  if (matches.length > 1) {
+    const ids = matches.map((m) => m.id).filter((id) => typeof id === "number");
+    throw new ResolutionError(
+      `whoAmI: "${value}" is ambiguous (matched ${matches.length} resources)`,
+      { code: "RESOLUTION_AMBIGUOUS", resourceIds: ids, details: { idRefs: ids.map((cid) => ({ entity: "resource", id: cid })) } }
+    );
+  }
+  return matches[0];
+}
+var WORKLOAD_OP = "resources.workload";
+async function workload(resource, id, opts = {}) {
+  const client = clientOf(resource, WORKLOAD_OP);
+  const ticketLimit = compositePartLimit(opts.ticketLimit, "ticketLimit", WORKLOAD_OP);
+  const taskLimit = compositePartLimit(opts.taskLimit, "taskLimit", WORKLOAD_OP);
+  const timeOffLimit = compositePartLimit(opts.timeOffLimit, "timeOffLimit", WORKLOAD_OP);
+  const resourceId = parseIdentifier(id, "id");
+  const root = await invokeRead(client, "resources.get", [resourceId]);
+  const strict = { allowAssumed: false };
+  const joined = await compositePart(client, "tickets.forResource", [
+    resourceId,
+    { openOnly: true, limit: Math.min(ticketLimit, 500), ...strict }
+  ]);
+  const counted = await compositePart(client, "tickets.forResource", [resourceId, { countOnly: true, ...strict }]);
+  const assignments = await compositePart(client, "service_call_task_resources.query", [
+    { filter: [{ field: "resourceID", op: "eq", value: resourceId }], limit: taskLimit }
+  ]);
+  const balances = await compositePart(client, "resource_time_off_balances.getByResource", [resourceId]);
+  const timeOff = await compositePart(client, "time_off_requests.query", [
+    { filter: [{ field: "resourceID", op: "eq", value: resourceId }], limit: timeOffLimit }
+  ]);
+  const openTickets = joined.value !== null && typeof joined.value === "object" ? counted.value !== null && typeof counted.value === "object" ? (() => {
+    const { primary, secondary, both, open, capped } = counted.value;
+    return {
+      ...joined,
+      value: { ...joined.value, totals: { primary, secondary, both, open, capped } }
+    };
+  })() : {
+    ...joined,
+    value: { ...joined.value, totalsAbsent: counted.absent ?? "NO_TOTALS" }
+  } : joined;
+  const taskIds = numericIds(
+    assignments.value?.items ?? [],
+    "serviceCallTaskID"
+  ).slice(0, IN_FILTER_CAP);
+  const taskDetails = taskIds.length === 0 ? { value: null, absent: "NO_ASSIGNMENTS" } : await compositePart(client, "service_call_tasks.query", [
+    { filter: [{ field: "taskID", op: "in", value: taskIds }], limit: taskLimit }
+  ]);
+  return {
+    root,
+    parts: {
+      open_tickets: openTickets,
+      task_assignments: assignments,
+      task_details: taskDetails,
+      time_off_balances: balances,
+      time_off_requests: timeOff
+    }
+  };
+}
+
+// src/resources/resources.ts
+var ResourcesResource = class extends BaseResource {
+  clientConfig;
+  constructor(http, clientConfig, pageSize) {
+    super(http, {
+      key: "resources",
+      resourcePath: "/V1.0/Resources",
+      deletable: false,
+      udfCapable: false,
+      collectionUpdate: true,
+      // D1: the spec's item path is GET-only — confirmed updates PUT the collection (id in the body)
+      searchFields: ["firstName", "lastName"]
+    }, pageSize);
+    this.clientConfig = clientConfig;
+  }
+  /** Query Resource records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every Resource 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). `fresh: true` bypasses the read-cache lookup and refreshes the entry (issue #250). */
+  async get(id, opts = {}) {
+    return this.getGlobal(id, opts?.fresh === true);
+  }
+  /** 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);
+  }
+  /** Resolve a Resource from a numeric id (or, where the vendor indexes a primary text field,
+   * from an exact match on firstName / lastName). A numeric id miss throws NOT_FOUND; a complete
+   * non-match returns null; ambiguity throws RESOLUTION_AMBIGUOUS (candidate ids) and a
+   * cap-tripped bounded client scan throws RESOLUTION_TRUNCATED (never a silent null).
+   * The compact shape is the structural alias of the full record; `expand: true` is the
+   * type-level escape hatch. */
+  async resolve(identifier, opts = {}) {
+    void opts;
+    return this.resolveBase(identifier);
+  }
+  /** Search Resource records: bounded contains on firstName + lastName (no vendor free-text search exists);
+   * limit defaults to 25, max 500. */
+  async search(query, opts) {
+    return this.searchBase(query, { limit: opts?.limit });
+  }
+  /** Node-parity special op (hand-written in src/resources/special/resources.ts). */
+  whoAmI() {
+    return whoAmI(this, this.clientConfig.userName);
+  }
+  /** Node-parity special op (hand-written in src/resources/special/resources.ts). */
+  workload(id, opts) {
+    return workload(this, id, opts);
+  }
+};
+
 // src/resources/special/resource_time_off_additional.ts
-async function getByResource(_resource, resourceId, http) {
+async function getByResource(_resource, resourceId) {
+  const http = _resource.http;
   const numericResource = parseIdentifier(resourceId, "resourceId");
   const res = await http.request({
     method: "GET",
@@ -5317,7 +5411,7 @@ var ResourceTimeOffAdditionalResource = class extends BaseResource {
   }
   /** Node-parity special op (hand-written in src/resources/special/resource_time_off_additional.ts). */
   getByResource(resourceId) {
-    return getByResource(this, resourceId, this.http);
+    return getByResource(this, resourceId);
   }
 };
 
@@ -5364,7 +5458,8 @@ var ResourceTimeOffApproversResource = class extends BaseResource {
 };
 
 // src/resources/special/resource_time_off_balances.ts
-async function getByResource2(_resource, resourceId, http) {
+async function getByResource2(_resource, resourceId) {
+  const http = _resource.http;
   const numericResource = parseIdentifier(resourceId, "resourceId");
   const res = await http.request({
     method: "GET",
@@ -5373,7 +5468,8 @@ async function getByResource2(_resource, resourceId, http) {
   });
   return unwrapItems(res, "resource_time_off_balances.getByResource").items;
 }
-async function getByYear(_resource, resourceId, year, http) {
+async function getByYear(_resource, resourceId, year) {
+  const http = _resource.http;
   const numericResource = parseIdentifier(resourceId, "resourceId");
   if (!Number.isSafeInteger(year) || year < 1) {
     throw new AutotaskConfigError("getByYear: year must be a positive integer");
@@ -5416,11 +5512,11 @@ var ResourceTimeOffBalancesResource = class extends BaseResource {
   }
   /** Node-parity special op (hand-written in src/resources/special/resource_time_off_balances.ts). */
   getByResource(resourceId) {
-    return getByResource2(this, resourceId, this.http);
+    return getByResource2(this, resourceId);
   }
   /** Node-parity special op (hand-written in src/resources/special/resource_time_off_balances.ts). */
   getByYear(resourceId, year) {
-    return getByYear(this, resourceId, year, this.http);
+    return getByYear(this, resourceId, year);
   }
 };
 
@@ -5534,6 +5630,37 @@ var SalesOrdersResource = class extends BaseResource {
   }
 };
 
+// src/resources/special/service_calls.ts
+var OP2 = "service_calls.fullProfile";
+async function fullProfile2(resource, id, opts = {}) {
+  const client = clientOf(resource, OP2);
+  const ticketLimit = compositePartLimit(opts.ticketLimit, "ticketLimit", OP2);
+  const taskLimit = compositePartLimit(opts.taskLimit, "taskLimit", OP2);
+  const callId = parseIdentifier(id, "id");
+  const root = await invokeRead(client, "service_calls.get", [callId]);
+  const tickets = await compositePart(client, "service_call_tickets.query", [
+    { filter: [{ field: "serviceCallID", op: "eq", value: callId }], limit: ticketLimit }
+  ]);
+  const tasks = await compositePart(client, "service_call_tasks.query", [
+    { filter: [{ field: "serviceCallID", op: "eq", value: callId }], limit: taskLimit }
+  ]);
+  const taskIds = numericIds(
+    tasks.value?.items ?? [],
+    "taskID"
+  ).slice(0, IN_FILTER_CAP);
+  const resourceAssignments = taskIds.length === 0 ? { value: null, absent: "NO_TASKS" } : await compositePart(client, "service_call_task_resources.query", [
+    { filter: [{ field: "taskID", op: "in", value: taskIds }], limit: taskLimit }
+  ]);
+  return {
+    root,
+    parts: {
+      tickets,
+      tasks,
+      resource_assignments: resourceAssignments
+    }
+  };
+}
+
 // src/resources/service_calls.ts
 var ServiceCallsResource = class extends BaseResource {
   constructor(http, pageSize) {
@@ -5601,6 +5728,10 @@ var ServiceCallsResource = class extends BaseResource {
     void opts;
     return this.resolveBase(identifier);
   }
+  /** Node-parity special op (hand-written in src/resources/special/service_calls.ts). */
+  fullProfile(id, opts) {
+    return fullProfile2(this, id, opts);
+  }
 };
 
 // src/resources/service_call_task_resources.ts
@@ -6893,23 +7024,203 @@ var TicketChangeRequestApprovalsResource = class extends BaseResource {
   }
 };
 
+// src/resources/special/_shared/move-engine.ts
+import { randomUUID } from "crypto";
+var MOVE_SOURCE_AGE_DEFAULT_DAYS = 14;
+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, ids, operation, extra = {}) => new MoveRefusedError(message, { code, operation, details: { status: "failed", ...ids, ...extra } });
+async function queryRows(http, resource, filter, operation, retries) {
+  const res = await http.request({ method: "POST", idempotent: true, path: `/V1.0/${resource}/query`, body: { MaxRecords: 5, filter }, operation, maxRetries: retries });
+  return unwrapItems(res).items;
+}
+function sameValue(a, b) {
+  if (a === null || a === void 0 || a === "") return b === null || b === void 0 || b === "";
+  if (b === null || b === void 0 || b === "") return false;
+  if (typeof a === "number" || typeof b === "number") return Math.abs(Number(a) - Number(b)) < 1e-9;
+  if (typeof a === "boolean" || typeof b === "boolean") return a === b;
+  if (typeof a === "string" && typeof b === "string") {
+    const iso2 = /^\d{4}-\d{2}-\d{2}T/;
+    if (iso2.test(a) && iso2.test(b)) return Date.parse(a) === Date.parse(b);
+    return a.trim() === b.trim();
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+async function readTicket(http, id, retries, operation) {
+  try {
+    const res = await http.request({ method: "GET", path: `/V1.0/Tickets/${id}`, operation, maxRetries: retries });
+    const item = res?.item;
+    return item ?? null;
+  } catch (e) {
+    if (isAutotaskError(e) && (e.httpStatus === 404 || e.code === "NOT_FOUND")) return null;
+    throw e;
+  }
+}
+async function preview(http, spec, sourceId, toTicketId, opts) {
+  const op = spec.operation;
+  const ids = { sourceId, toTicketId };
+  const source = await spec.readSource(http, sourceId, opts.maxRetries);
+  if (source === null) throw refuse("MOVE_SOURCE_NOT_FOUND", `${op}: source ${spec.entity} ${sourceId} does not exist`, ids, op);
+  const sourceTicketId = spec.sourceTicketId(source);
+  if (typeof sourceTicketId !== "number") {
+    throw refuse("MOVE_SOURCE_UNSUPPORTED", `${op}: source ${spec.entity} ${sourceId} is not attached to a ticket (task and internal records are not moved)`, ids, op);
+  }
+  if (sourceTicketId === toTicketId) throw refuse("MOVE_TARGET_SAME", `${op}: target ticket ${toTicketId} is the source's current ticket`, ids, op);
+  if (opts.lastModifiedDate !== void 0) {
+    const current = source.lastModifiedDateTime ?? source.lastModifiedDate;
+    if (current !== opts.lastModifiedDate) {
+      throw refuse("STALE_OBJECT", `${op}: source ${spec.entity} ${sourceId} was modified since the snapshot`, ids, op);
+    }
+  }
+  const cap = opts.maxSourceAgeDays === void 0 ? MOVE_SOURCE_AGE_DEFAULT_DAYS : Math.min(MOVE_SOURCE_AGE_DEFAULT_DAYS, opts.maxSourceAgeDays);
+  if (!Number.isFinite(cap) || cap < 0) throw new AutotaskConfigError(`${op}: maxSourceAgeDays must be a number >= 0`);
+  const when = Date.parse(String(source[spec.dateField] ?? ""));
+  if (!Number.isFinite(when) || Date.now() - when > cap * 864e5) {
+    throw refuse("MOVE_SOURCE_TOO_OLD", `${op}: source ${spec.entity} ${sourceId} is older than ${cap} day(s) (or undated) \u2014 move it in the Autotask UI`, ids, op, { manualAction: manualFor(http, spec, source, "older than the move age limit") });
+  }
+  const target = await readTicket(http, toTicketId, opts.maxRetries, op);
+  if (target === null) throw refuse("MOVE_TARGET_MISSING", `${op}: target ticket ${toTicketId} does not exist`, ids, 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"}`,
+      ids,
+      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,
+    companyChanged: origin === null ? null : origin.companyID !== target.companyID,
+    contractChanged: origin === null ? null : (origin.contractID ?? null) !== (target.contractID ?? null)
+  };
+  const ctx = { http, spec, sourceId, source, sourceTicketId, toTicketId, facts, retries: opts.maxRetries };
+  await spec.checkSource(ctx);
+  const sameScope = facts.companyChanged === false && facts.contractChanged === false;
+  const payload = spec.buildPayload(source, toTicketId, { sameScope });
+  await assertNoTwin(ctx, payload);
+  return { ctx, payload };
+}
+function manualFor(http, spec, source, reason) {
+  return { action: "delete_source", uiLink: spec.manualLink(http, source), reason };
+}
+async function assertNoTwin(ctx, payload) {
+  const q = ctx.spec.twinQuery(payload);
+  const rows = await queryRows(ctx.http, q.resource, q.filter, ctx.spec.operation, ctx.retries);
+  if (rows.length > 0) {
+    throw refuse("MOVE_TARGET_HAS_TWIN", `${ctx.spec.operation}: target ticket ${ctx.toTicketId} already has an equivalent ${ctx.spec.entity} (id ${String(rows[0].id)}) \u2014 a duplicate or resumed move`, { sourceId: ctx.sourceId, toTicketId: ctx.toTicketId }, ctx.spec.operation, { twinId: rows[0].id });
+  }
+}
+var statusOf = (e) => isAutotaskError(e) ? e.httpStatus : void 0;
+async function runMove(http, spec, sourceIdIn, toTicketIn, opts = {}) {
+  const op = spec.operation;
+  const sourceId = Number(parseIdentifier(sourceIdIn, "sourceId"));
+  const toTicketId = Number(parseIdentifier(toTicketIn, "toTicketId"));
+  if (!Number.isSafeInteger(sourceId) || !Number.isSafeInteger(toTicketId)) {
+    throw new AutotaskConfigError(`${op}: sourceId and toTicketId must be safe integers`);
+  }
+  const { ctx, payload } = await preview(http, spec, sourceId, toTicketId, opts);
+  if (opts.dryRun === true) {
+    return buildDryRunResult(
+      {
+        operation: op,
+        method: "POST",
+        path: spec.createPath(toTicketId),
+        ids: [sourceId],
+        checks: [
+          { name: "source-exists", ok: true },
+          { name: "target-open", ok: true },
+          { name: "invariants", ok: true },
+          { name: "no-twin-on-target", ok: true }
+        ],
+        impact: { affected: 2, scope: "create-then-delete", reversible: false },
+        warnings: [MOVE_EFFECTS_NOTE, ...ctx.facts.companyChanged === true ? ["the target ticket belongs to a different company"] : []],
+        data: payload
+      },
+      { redactPersonalData: http.redactPersonalData }
+    );
+  }
+  const correlationId = randomUUID();
+  const ids = { sourceId, toTicketId, correlationId };
+  await assertNoTwin(ctx, payload);
+  let newId;
+  try {
+    const created = await http.request({ method: "POST", path: spec.createPath(toTicketId), body: payload, operation: op, maxRetries: 0 });
+    newId = Number(unwrapOperation(created, op).id);
+  } catch (e) {
+    const status = statusOf(e);
+    if (status !== void 0 && status >= 400 && status < 500) {
+      throw new MoveRefusedError(`${op}: the vendor refused the create \u2014 nothing changed`, { code: "MOVE_CREATE_REFUSED", operation: op, httpStatus: status, details: { status: "failed", ...ids } });
+    }
+    throw new MoveRefusedError(`${op}: the create outcome is unknown (never resent) \u2014 check the target ticket for a new ${spec.entity} before retrying; the twin check blocks a second create`, { code: "MOVE_UNKNOWN", operation: op, details: { status: "unknown", ...ids } });
+  }
+  const rollback = async (code, message) => {
+    try {
+      await http.request({ method: "DELETE", path: spec.deletePath(newId, toTicketId), operation: op, maxRetries: 0 });
+    } catch (re) {
+      const unreadable = statusOf(re) === void 0 || (statusOf(re) ?? 0) >= 500;
+      throw new MoveRefusedError(`${op}: ${message}; rolling back the new ${spec.entity} ${newId} FAILED \u2014 both records exist`, { code: unreadable ? "MOVE_UNKNOWN" : "MOVE_PARTIAL", operation: op, details: { status: unreadable ? "unknown" : "partial", ...ids, newId, reason: code } });
+    }
+    throw new MoveRefusedError(`${op}: ${message}; the new ${spec.entity} ${newId} was rolled back, the source is unchanged`, { code, operation: op, details: { status: "failed", ...ids, newId } });
+  };
+  const fresh = await spec.readById(http, newId, toTicketId).catch(() => null);
+  if (fresh === null) return rollback("MOVE_VERIFY_FAILED", "the new record could not be read back");
+  const mismatched = [...spec.verifyFields, "ticketID"].filter((f) => !sameValue(f === "ticketID" ? toTicketId : payload[f], fresh[f]));
+  if (mismatched.length > 0) return rollback("MOVE_VERIFY_FAILED", `the read-back differs on ${mismatched.join(", ")}`);
+  const again = await spec.readSource(http, sourceId, void 0).catch(() => null);
+  if (again === null) {
+    return { status: "moved_source_absent", sourceId, newId, correlationId, snapshot: ctx.source, facts: ctx.facts };
+  }
+  const changed = [...spec.guardFields].filter((f) => !sameValue(ctx.source[f], again[f]));
+  if (changed.length > 0) return rollback("MOVE_SOURCE_CHANGED", `the source changed after the preview (${changed.join(", ")})`);
+  try {
+    await http.request({ method: "DELETE", path: spec.deletePath(sourceId, ctx.sourceTicketId), operation: op, maxRetries: 0 });
+  } catch (e) {
+    const status = statusOf(e);
+    if (status === 404) return { status: "moved_source_absent", sourceId, newId, correlationId, snapshot: ctx.source, facts: ctx.facts };
+    if (status !== void 0 && status >= 400 && status < 500) {
+      return {
+        status: "moved_manual_delete",
+        sourceId,
+        newId,
+        correlationId,
+        snapshot: ctx.source,
+        facts: ctx.facts,
+        manualAction: manualFor(http, spec, ctx.source, `the vendor refused to delete the source (HTTP ${status}); the verified copy exists on the target \u2014 delete the source in the Autotask UI`)
+      };
+    }
+    if (status === void 0) {
+      throw new MoveRefusedError(`${op}: the source delete outcome is unknown (never resent) \u2014 re-read the source: absent means the move completed`, { code: "MOVE_UNKNOWN", operation: op, details: { status: "unknown", ...ids, newId } });
+    }
+    return rollback("MOVE_SOURCE_DELETE_FAILED", `the source delete failed (HTTP ${status})`);
+  }
+  return { status: "moved", sourceId, newId, correlationId, snapshot: ctx.source, facts: ctx.facts };
+}
+function uiLinkFor(http, entity, id) {
+  return buildUiLink({ entity, id, baseUrl: http.baseUrl }) ?? null;
+}
+
 // src/resources/special/ticket_charges.ts
-var OP = "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 }], OP, 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", `${OP}: ticket charge ${sourceId} is billed \u2014 move it in the Autotask UI`, { sourceId, toTicketId }, OP, {
+    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: OP,
+  operation: OP3,
   entity: "ticket_charge",
   readSource: readCharge,
   sourceTicketId: (s) => typeof s.ticketID === "number" ? s.ticketID : null,
@@ -6940,8 +7251,8 @@ var SPEC = {
   // charges have no ExecuteCommand code: the parent ticket is the closest clickable target
   manualLink: (http, source) => typeof source.ticketID === "number" ? uiLinkFor(http, "tickets", source.ticketID) : null
 };
-function moveToTicket(_resource, sourceId, toTicketId, opts, http) {
-  return runMove(http, SPEC, sourceId, toTicketId, opts);
+function moveToTicket(resource, sourceId, toTicketId, opts) {
+  return runMove(resource.http, SPEC, sourceId, toTicketId, opts);
 }
 
 // src/resources/ticket_charges.ts
@@ -7015,7 +7326,7 @@ var TicketChargesResource = class extends BaseResource {
   }
   /** Node-parity special op (hand-written in src/resources/special/ticket_charges.ts). */
   moveToTicket(sourceId, toTicketId, opts = {}) {
-    return moveToTicket(this, sourceId, toTicketId, opts, this.http);
+    return moveToTicket(this, sourceId, toTicketId, opts);
   }
 };
 
@@ -7438,765 +7749,246 @@ var TicketSecondaryResourcesResource = class extends BaseResource {
   }
 };
 
-// src/resources/special/tickets/common.ts
-async function fetchTicket(http, id, operation) {
-  const res = await http.request({
-    method: "GET",
-    path: `/V1.0/Tickets/${id}`,
-    operation
-  });
-  const body = res;
-  if (body === null || !("item" in body)) {
-    throw new NotFoundError(`Ticket ${id} not found (unexpected envelope shape)`, { resourceIds: [id], details: { idRefs: [{ entity: "ticket", id }] } });
+// src/resources/special/tickets/errors.ts
+var StatusUnknownError = class extends AutotaskError {
+  /** The live picklist size (the message names it; the values + labels are via operations.fieldCatalog with labels: true). */
+  picklistCount;
+  constructor(message, options = {}) {
+    super(message, {
+      code: "STATUS_UNKNOWN",
+      category: "validation",
+      suggestedAction: `Pass one of the tenant's live status values (discover the current values + labels with operations.fieldCatalog({ resources: ["tickets"], fields: ["status"], labels: true })).`,
+      ...options
+    });
+    this.name = "StatusUnknownError";
+    this.picklistCount = options.picklistCount ?? 0;
   }
-  if (body.item === null || body.item === void 0) throw new NotFoundError(`Ticket ${id} not found`, { resourceIds: [id], details: { idRefs: [{ entity: "ticket", id }] } });
-  return body.item;
-}
-async function ticketQueryItems(http, path, filter, maxRecords, operation) {
-  const res = await http.request({
-    method: "POST",
-    idempotent: true,
-    path,
-    body: { MaxRecords: maxRecords, filter },
-    operation
-  });
-  return unwrapItems(res).items;
-}
-function truncate(text, limit) {
-  const full = text ?? "";
-  if (full.length <= limit) return { value: full, truncated: false, length: full.length };
-  return { value: `${full.slice(0, limit)}\u2026`, truncated: true, length: full.length };
-}
+};
+var StatusFieldsRequiredError = class extends AutotaskError {
+  vendorFields;
+  currentStatus;
+  targetStatus;
+  currentValues;
+  constructor(message, details, options = {}) {
+    super(message, { code: "STATUS_FIELDS_REQUIRED", category: "validation", suggestedAction: "Pass the required field value(s) in the `fields` argument and retry (the node never fills a field without a proven-safe default).", ...options });
+    this.name = "StatusFieldsRequiredError";
+    this.vendorFields = details.vendorFields;
+    this.currentStatus = details.currentStatus;
+    this.targetStatus = details.targetStatus;
+    this.currentValues = details.currentValues;
+  }
+};
 
-// src/resources/special/tickets/childRead.ts
-function isRouteUnavailable(err) {
-  return isAutotaskError(err) && (err.httpStatus === 404 || err.httpStatus === 500);
+// src/resources/special/tickets/writeSupport.ts
+var OP_STATUS = "tickets.changeStatus";
+var MAX_DISCOVERY_MERGES = 3;
+function isPositiveInt(v) {
+  return typeof v === "number" && Number.isInteger(v) && v > 0;
 }
-function routeFact(route, path, err) {
-  return {
-    route,
-    path,
-    httpStatus: isAutotaskError(err) && typeof err.httpStatus === "number" ? err.httpStatus : null
-  };
+function namedVendorFields(err) {
+  if (!isAutotaskError(err) || err.vendorError === void 0) return [];
+  const entries = parseVendorErrors(err.vendorError) ?? [];
+  const out = /* @__PURE__ */ new Set();
+  for (const e of entries) if (e.field !== void 0) out.add(e.field);
+  return [...out];
 }
-function childDeclaresQuery(resourceKey) {
-  return CAPABILITIES.some(
-    (c) => c.id === `${resourceKey}.query` && (c.status === "implemented" || c.status === "tested")
-  );
+async function fetchItem(http, path, operation, readOpts) {
+  const res = await http.request({ method: "GET", path, operation, maxRetries: readOpts?.maxRetries });
+  return unwrapItemOrNull(res);
 }
-function planScopedPath(resourceKey, ticketId) {
-  if (!childDeclaresQuery(resourceKey)) return null;
-  const entry = RELATIONSHIP_MAP[resourceKey];
-  const parent = entry === void 0 ? null : entry.parent;
-  if (parent === null || parent.resource !== "tickets" || parent.segment === null || parent.field === null) return null;
-  const parentPath = RELATIONSHIP_MAP[parent.resource]?.path;
-  if (parentPath === null || parentPath === void 0) return null;
-  return `/V1.0/${parentPath}/${ticketId}/${parent.segment}`;
+async function fetchItemUnredacted(http, path, operation, readOpts) {
+  const res = await http.request({ method: "GET", path, operation, skipResponseRedaction: true, maxRetries: readOpts?.maxRetries });
+  return unwrapItemOrNull(res);
 }
-function scopedRowMatches(row, filter) {
-  let conds;
-  if (Array.isArray(filter)) conds = filter;
-  else if (filter !== null && typeof filter === "object" && Array.isArray(filter.filter)) {
-    conds = filter.filter;
-  }
-  if (conds === void 0) return true;
-  for (const raw of conds) {
-    if (raw === null || typeof raw !== "object") return false;
-    const cond = raw;
-    if (typeof cond.field !== "string" || typeof cond.op !== "string") return false;
-    if (cond.field === "ticketID") continue;
-    const value = row[cond.field];
-    if (typeof value !== "string") return false;
-    const want = String(cond.value ?? "");
-    if (cond.op === "eq" && value !== want) return false;
-    if (cond.op === "gt" && !(value > want)) return false;
-    if (cond.op === "lt" && !(value < want)) return false;
-    if (cond.op !== "eq" && cond.op !== "gt" && cond.op !== "lt") return false;
+function unwrapItemOrNull(res) {
+  const body = res;
+  if (body === null || !("item" in body) || body.item === null || body.item === void 0) return null;
+  return body.item;
+}
+function discoveryMerge(err, body, defaults) {
+  if (!isAutotaskError(err) || err.vendorError === void 0) return null;
+  const entries = parseVendorErrors(err.vendorError);
+  if (entries === void 0) return null;
+  for (const entry of entries) {
+    const field = entry.field;
+    if (field === void 0 || body[field] !== void 0) continue;
+    if (defaults[field] === void 0) continue;
+    return { field, value: defaults[field] };
   }
-  return true;
+  return null;
 }
-var SCOPED_FALLBACK_PAGE_CAP = 10;
-async function scopedCollectionRead(http, startPath, limit, operation, accept) {
-  let target = startPath;
-  const items = [];
-  let guard = false;
-  let pages = 0;
-  let nextCursor = null;
-  for (; ; ) {
-    if (pages >= SCOPED_FALLBACK_PAGE_CAP) {
-      guard = true;
-      break;
+
+// src/resources/special/tickets/changeStatus.ts
+var STATUS_REQUIRED_FIELDS = {
+  // <discovery output lands here — e.g. 8: { requiredFields: ['dueDateTime'], safeDefaults: { dueDateTime: '<now>' } }>
+};
+async function readLiveStatusSet(resource) {
+  const raw = await resource.getFieldInfo();
+  const row = raw.find((f) => f.name === "status");
+  const values = row !== void 0 && row.isPickList === true ? row.picklistValues : void 0;
+  const ids = /* @__PURE__ */ new Set();
+  if (Array.isArray(values)) {
+    for (const pv of values) {
+      const n = Number(pv.value);
+      if (Number.isFinite(n)) ids.add(n);
     }
-    const body = await http.request({ method: "GET", path: target, operation });
-    const { items: pageItems, pageDetails } = unwrapItems(body, operation);
-    nextCursor = pageDetails.nextPageUrl;
-    pages += 1;
-    const window = pageItems.slice(0, Math.max(0, limit - items.length));
-    for (const row of window) if (accept(row)) items.push(row);
-    if (items.length >= limit) break;
-    if (nextCursor === null || pageItems.length === 0) break;
-    target = cursorToPath(http.baseUrl, nextCursor);
   }
-  const capped = items.length >= limit || guard && nextCursor !== null;
-  return { items, capped };
+  return ids;
 }
-async function ticketChildRead(http, spec, ticketId) {
+var GUARD_DEGRADED_WARNING = "the tenant's live status picklist metadata was unavailable (the local guard is degraded for this call \u2014 the W-A4 wall or a metadata failure); the vendor's own validation is the final authority on the status value";
+async function guardTargetStatus(resource, http, targetStatus) {
+  let liveStatus = null;
   try {
-    const items = await ticketQueryItems(http, spec.globalPath, spec.filter, spec.limit, spec.operation);
-    return { items, capped: items.length >= spec.limit, status: "ok", routeFacts: [] };
+    const ids = await readLiveStatusSet(resource);
+    if (ids.size > 0) liveStatus = ids;
   } catch (err) {
-    if (!isRouteUnavailable(err)) throw err;
-    const facts = [routeFact("global", spec.globalPath, err)];
-    const scopedPath = planScopedPath(spec.resourceKey, ticketId);
-    if (scopedPath === null) return { items: [], capped: false, status: "miss", routeFacts: facts };
+    if (!isAutotaskError(err) || err.code === "ABORTED") throw err;
+  }
+  if (liveStatus !== null && !liveStatus.has(targetStatus)) {
+    http.fieldCache?.invalidate("tickets:");
+    let freshStatus = null;
+    let reReadFailed = false;
     try {
-      const read = await scopedCollectionRead(http, scopedPath, spec.limit, spec.operation, (row) => scopedRowMatches(row, spec.filter));
-      return { ...read, status: "ok-scoped", routeFacts: [] };
-    } catch (scopedErr) {
-      facts.push(routeFact("scoped", scopedPath, scopedErr));
-      return { items: [], capped: false, status: "miss", routeFacts: facts };
+      const freshIds = await readLiveStatusSet(resource);
+      if (freshIds.size > 0) freshStatus = freshIds;
+    } catch (err) {
+      if (!isAutotaskError(err) || err.code === "ABORTED") throw err;
+      freshStatus = null;
+      reReadFailed = true;
+    }
+    if (freshStatus !== null && freshStatus.has(targetStatus)) {
+      liveStatus = freshStatus;
+    } else {
+      const verdict = freshStatus ?? liveStatus;
+      const staleNote = freshStatus === null ? `; the live re-read ${reReadFailed ? "failed" : "returned no values"}, so this picklist count is from the initial read (up to one field-cache TTL old)` : "";
+      throw new StatusUnknownError(
+        `changeStatus: targetStatus ${targetStatus} is not in the tenant's live status picklist (live: ${verdict.size} values \u2014 the entity metadata is the oracle; the values + labels are discoverable with operations.fieldCatalog({ resources: ["tickets"], fields: ["status"], labels: true })${staleNote})`,
+        { operation: OP_STATUS, picklistCount: verdict.size }
+      );
     }
   }
+  return { guardDegraded: liveStatus === null };
 }
-function applyRouteStatus(part, read) {
-  if (read.status === "ok-scoped") part.route = "scoped";
-  if (read.status === "miss") part.routeFacts = read.routeFacts;
-}
-
-// src/resources/special/tickets/sla.ts
-var MS = 864e5;
-var SLA_PAGE = 100;
-async function slaHealthCheck(_resource, id, opts = {}, http) {
-  void opts;
-  const ticketId = parseIdentifier(id, "id");
-  await fetchTicket(http, ticketId, "tickets.slaHealthCheck");
-  const rows = await ticketQueryItems(
-    http,
-    "/V1.0/ServiceLevelAgreementResults/query",
-    [{ field: "ticketID", op: "eq", value: ticketId }],
-    SLA_PAGE,
-    "tickets.slaHealthCheck"
+function noChangeDryRun(http, ticketId, targetStatus, guardDegraded) {
+  return buildDryRunResult(
+    {
+      operation: OP_STATUS,
+      method: "PUT",
+      path: "/V1.0/Tickets",
+      ids: [ticketId],
+      checks: [
+        { name: "status-known", ok: true },
+        { name: "merge-read", ok: true },
+        { name: "no-op", ok: true }
+      ],
+      impact: { affected: 0, scope: "single-record", reversible: true },
+      warnings: [
+        ...guardDegraded ? [GUARD_DEGRADED_WARNING] : [],
+        `NO_CHANGE: the ticket is already in the target status ${targetStatus} \u2014 the apply would be a zero-wire no-op.`
+      ],
+      data: { reason: "NO_CHANGE", status: targetStatus }
+    },
+    { redactPersonalData: http.redactPersonalData }
   );
-  const slas = rows.map((row) => {
-    const bool = (v) => typeof v === "boolean" ? v : null;
-    const num = (v) => typeof v === "number" ? v : null;
-    const milestones = [
-      { name: "firstResponse", met: bool(row.isFirstResponseMet), elapsedHours: num(row.firstResponseElapsedHours) },
-      { name: "resolution", met: bool(row.isResolutionMet), elapsedHours: num(row.resolutionElapsedHours) },
-      { name: "resolutionPlan", met: bool(row.isResolutionPlanMet), elapsedHours: num(row.resolutionPlanElapsedHours) }
-    ];
-    return { id: Number(row.id), name: row.serviceLevelAgreementName ?? null, milestones };
-  });
-  const healthy = slas.every((sla) => sla.milestones.every((m) => m.met === true));
-  return { ticketId, slaCount: slas.length, healthy, slas, truncated: rows.length >= SLA_PAGE };
 }
-async function summary(_resource, id, opts = {}, http) {
-  const limit = opts.summaryTextLimit === void 0 ? 500 : Math.trunc(opts.summaryTextLimit);
-  if (!Number.isInteger(limit) || limit < 1) {
-    throw new AutotaskConfigError(`summaryTextLimit must be an integer >= 1 (got ${String(opts.summaryTextLimit)})`);
+function resolveMergeData(ticketId, targetStatus, previousStatus, current, fields, mapEntry) {
+  const mergeData = { status: targetStatus };
+  for (const [k, v] of Object.entries(fields ?? {})) {
+    if (v !== void 0) mergeData[k] = v;
   }
-  const ticketId = parseIdentifier(id, "id");
-  const ticket = await fetchTicket(http, ticketId, "tickets.summary");
-  const desc = truncate(ticket.description, limit);
-  const now = opts.now ?? /* @__PURE__ */ new Date();
-  const ageDays = typeof ticket.createDate === "string" && ticket.createDate !== "" ? Math.max(0, Math.floor((now.getTime() - Date.parse(ticket.createDate)) / MS)) : null;
-  const pick = (v) => typeof v === "number" ? v : null;
-  const str = (v) => typeof v === "string" && v !== "" ? v : null;
-  return {
-    ticketId,
-    ticketNumber: str(ticket.ticketNumber),
-    title: str(ticket.title),
-    description: desc.value,
-    descriptionLength: desc.length,
-    descriptionTruncated: desc.truncated,
-    status: pick(ticket.status),
-    priority: pick(ticket.priority),
-    companyID: pick(ticket.companyID),
-    contactID: pick(ticket.contactID),
-    assignedResourceID: pick(ticket.assignedResourceID),
-    projectID: pick(ticket.projectID),
-    createDate: str(ticket.createDate),
-    dueDateTime: str(ticket.dueDateTime),
-    ageDays
-  };
-}
-
-// src/resources/special/tickets/timeline.ts
-function validateTimelineLimits(opts) {
-  const limit = opts.limit === void 0 ? 100 : Math.trunc(opts.limit);
-  if (!Number.isInteger(limit) || limit < 1) throw new AutotaskConfigError(`limit must be an integer >= 1 (got ${String(opts.limit)})`);
-  const bounded = Math.min(limit, 500);
-  const textLimit = opts.textLimit === void 0 ? 500 : Math.trunc(opts.textLimit);
-  if (!Number.isInteger(textLimit) || textLimit < 1) {
-    throw new AutotaskConfigError(`textLimit must be an integer >= 1 (got ${String(opts.textLimit)})`);
+  const filled = [];
+  if (mapEntry !== void 0) {
+    for (const field of mapEntry.requiredFields) {
+      if (mergeData[field] !== void 0) continue;
+      if (current[field] !== null && current[field] !== void 0) continue;
+      const safe = mapEntry.safeDefaults?.[field];
+      if (safe === void 0) {
+        throw new StatusFieldsRequiredError(
+          `changeStatus: status ${targetStatus} requires the field '${field}' and the live-discovered map has no proven-safe default for it \u2014 the op is safe-without-the-map (never a blind full update): supply the value in fields and retry`,
+          { vendorFields: [field], currentStatus: previousStatus, targetStatus, currentValues: { [field]: current[field] ?? null } },
+          { operation: OP_STATUS, resourceIds: [ticketId], details: { idRefs: [{ entity: "ticket", id: ticketId }] } }
+        );
+      }
+      mergeData[field] = safe;
+      filled.push(field);
+    }
   }
-  return { bounded, textLimit };
+  return { mergeData, filled };
 }
-function noteEvent(n, textLimit) {
-  const text = truncate(typeof n.description === "string" ? n.description : null, textLimit);
-  return {
-    kind: "note",
-    id: Number(n.id),
-    date: typeof n.createDateTime === "string" ? n.createDateTime : null,
-    text: text.value || null,
-    title: typeof n.title === "string" ? n.title : null,
-    hours: null,
-    action: null,
-    textTruncated: text.truncated
-  };
-}
-function timeEntryEvent(t) {
-  return {
-    kind: "timeEntry",
-    id: Number(t.id),
-    date: typeof t.dateWorked === "string" ? t.dateWorked : null,
-    text: null,
-    title: null,
-    hours: typeof t.hoursWorked === "number" ? t.hoursWorked : null,
-    action: null,
-    textTruncated: false
-  };
-}
-function historyEvent(h, textLimit) {
-  const text = truncate(typeof h.detail === "string" ? h.detail : null, textLimit);
-  return {
-    kind: "history",
-    id: Number(h.id),
-    date: typeof h.date === "string" ? h.date : null,
-    text: text.value || null,
-    title: null,
-    hours: null,
-    action: typeof h.action === "string" ? h.action : null,
-    textTruncated: text.truncated
-  };
-}
-function compareEventDates(a, b) {
-  const da = a.date ?? "";
-  const db = b.date ?? "";
-  if (da === "" && db === "") return 0;
-  if (da === "") return 1;
-  if (db === "") return -1;
-  return da < db ? -1 : da > db ? 1 : 0;
-}
-async function timeline(_resource, id, opts = {}, http) {
-  const { bounded, textLimit } = validateTimelineLimits(opts);
-  const ticketId = parseIdentifier(id, "id");
-  await fetchTicket(http, ticketId, "tickets.timeline");
-  const dateFilters = (field) => {
-    const f = [{ field: "ticketID", op: "eq", value: ticketId }];
-    if (opts.since !== void 0) f.push({ field, op: "gt", value: opts.since });
-    if (opts.until !== void 0) f.push({ field, op: "lt", value: opts.until });
-    return f;
-  };
-  const events = [];
-  const cappedSources = [];
-  const notes = await ticketChildRead(http, { globalPath: "/V1.0/TicketNotes/query", resourceKey: "ticket_notes", filter: dateFilters("createDateTime"), limit: bounded, operation: "tickets.timeline" }, ticketId);
-  if (notes.capped) cappedSources.push("notes");
-  for (const n of notes.items) events.push(noteEvent(n, textLimit));
-  const entries = await ticketChildRead(http, { globalPath: "/V1.0/TimeEntries/query", resourceKey: "time_entries", filter: dateFilters("dateWorked"), limit: bounded, operation: "tickets.timeline" }, ticketId);
-  if (entries.capped) cappedSources.push("timeEntries");
-  for (const t of entries.items) events.push(timeEntryEvent(t));
-  let historiesRead;
-  if (opts.includeHistories) {
-    historiesRead = await ticketChildRead(http, { globalPath: "/V1.0/TicketHistory/query", resourceKey: "ticket_history", filter: dateFilters("date"), limit: bounded, operation: "tickets.timeline" }, ticketId);
-    if (historiesRead.capped) cappedSources.push("histories");
-    for (const h of historiesRead.items) events.push(historyEvent(h, textLimit));
-  }
-  events.sort(compareEventDates);
-  const capped = events.slice(0, bounded);
-  const result = {
-    ticketId,
-    count: capped.length,
-    events: capped,
-    truncated: cappedSources.length > 0 || events.length > bounded,
-    cappedSources
-  };
-  if (notes.status !== "ok" || entries.status !== "ok" || historiesRead !== void 0 && historiesRead.status !== "ok") {
-    const routes = { notes: notes.status, timeEntries: entries.status };
-    if (historiesRead !== void 0) routes.histories = historiesRead.status;
-    result.sourceRoutes = routes;
-  }
-  return result;
-}
-
-// src/resources/special/tickets/errors.ts
-var QueueRequiredError = class extends AutotaskError {
-  constructor(message, options = {}) {
-    super(message, {
-      code: "QUEUE_REQUIRED",
-      category: "validation",
-      suggestedAction: "pass params.queueID (discover via autotask_describe(tickets.create) or a known queue id)",
-      ...options
-    });
-    this.name = "QueueRequiredError";
-  }
-};
-var TicketResourceInvalidError = class extends AutotaskError {
-  constructor(message, options = {}) {
-    super(message, { code: "RESOURCE_INVALID", category: "validation", ...options });
-    this.name = "TicketResourceInvalidError";
-  }
-};
-var TicketCreateValidationFailedError = class extends AutotaskError {
-  /** The vendor-named fields (empty when the 500 body named nothing parseable). */
-  vendorFields;
-  constructor(message, vendorFields, options = {}) {
-    super(message, { code: "VALIDATION_FAILED", category: "validation", ...options });
-    this.name = "TicketCreateValidationFailedError";
-    this.vendorFields = vendorFields;
-  }
-};
-var StatusUnknownError = class extends AutotaskError {
-  /** The live picklist size (the message names it; the values + labels are via operations.fieldCatalog with labels: true). */
-  picklistCount;
-  constructor(message, options = {}) {
-    super(message, {
-      code: "STATUS_UNKNOWN",
-      category: "validation",
-      suggestedAction: `Pass one of the tenant's live status values (discover the current values + labels with operations.fieldCatalog({ resources: ["tickets"], fields: ["status"], labels: true })).`,
-      ...options
-    });
-    this.name = "StatusUnknownError";
-    this.picklistCount = options.picklistCount ?? 0;
-  }
-};
-var StatusFieldsRequiredError = class extends AutotaskError {
-  vendorFields;
-  currentStatus;
-  targetStatus;
-  currentValues;
-  constructor(message, details, options = {}) {
-    super(message, { code: "STATUS_FIELDS_REQUIRED", category: "validation", suggestedAction: "Pass the required field value(s) in the `fields` argument and retry (the node never fills a field without a proven-safe default).", ...options });
-    this.name = "StatusFieldsRequiredError";
-    this.vendorFields = details.vendorFields;
-    this.currentStatus = details.currentStatus;
-    this.targetStatus = details.targetStatus;
-    this.currentValues = details.currentValues;
-  }
-};
-
-// src/resources/special/tickets/writeSupport.ts
-var OP_OPEN = "tickets.openWithNoteAndAssign";
-var OP_STATUS = "tickets.changeStatus";
-var MAX_DISCOVERY_MERGES = 3;
-function isPositiveInt(v) {
-  return typeof v === "number" && Number.isInteger(v) && v > 0;
-}
-function namedVendorFields(err) {
-  if (!isAutotaskError(err) || err.vendorError === void 0) return [];
-  const entries = parseVendorErrors(err.vendorError) ?? [];
-  const out = /* @__PURE__ */ new Set();
-  for (const e of entries) if (e.field !== void 0) out.add(e.field);
-  return [...out];
-}
-function vendorDetailOf(err) {
-  return isAutotaskError(err) ? formatVendorDetail(err.vendorError) : void 0;
-}
-async function fetchItem(http, path, operation, readOpts) {
-  const res = await http.request({ method: "GET", path, operation, maxRetries: readOpts?.maxRetries });
-  return unwrapItemOrNull(res);
-}
-async function fetchItemUnredacted(http, path, operation, readOpts) {
-  const res = await http.request({ method: "GET", path, operation, skipResponseRedaction: true, maxRetries: readOpts?.maxRetries });
-  return unwrapItemOrNull(res);
-}
-function unwrapItemOrNull(res) {
-  const body = res;
-  if (body === null || !("item" in body) || body.item === null || body.item === void 0) return null;
-  return body.item;
-}
-function operationId(res) {
-  const body = res;
-  if (body === null) return void 0;
-  return typeof body.itemId === "number" ? body.itemId : typeof body.id === "number" ? body.id : void 0;
-}
-function discoveryMerge(err, body, defaults) {
-  if (!isAutotaskError(err) || err.vendorError === void 0) return null;
-  const entries = parseVendorErrors(err.vendorError);
-  if (entries === void 0) return null;
-  for (const entry of entries) {
-    const field = entry.field;
-    if (field === void 0 || body[field] !== void 0) continue;
-    if (defaults[field] === void 0) continue;
-    return { field, value: defaults[field] };
-  }
-  return null;
-}
-function stepErrorText(code, err) {
-  const detail = vendorDetailOf(err);
-  const base = isAutotaskError(err) ? err.message : String(err);
-  return detail ? `${code}: ${detail}` : `${code}: ${base}`;
-}
-
-// src/resources/special/tickets/openWithNoteAndAssign.ts
-var DEFAULT_TICKET_PRIORITY = 3;
-var DEFAULT_TICKET_STATUS = 1;
-var DEFAULT_NOTE_TYPE = 1;
-var DEFAULT_PUBLISH = 1;
-var PUBLISH_VALUES = /* @__PURE__ */ new Set([1, 2, 4]);
-var SAFE_TICKET_CREATE_DEFAULTS = {};
-function validateOpenInput(params, note, assign) {
-  const companyID = parseIdentifier(params?.companyID, "params.companyID");
-  const title = params?.title;
-  if (typeof title !== "string" || title.trim() === "") {
-    throw new AutotaskConfigError("openWithNoteAndAssign: params.title is required (a non-empty string)", { operation: OP_OPEN });
-  }
-  const priority = params.priority ?? DEFAULT_TICKET_PRIORITY;
-  const status = params.status ?? DEFAULT_TICKET_STATUS;
-  if (!isPositiveInt(priority)) {
-    throw new AutotaskConfigError(`openWithNoteAndAssign: params.priority must be a positive integer (got ${String(params.priority)})`, { operation: OP_OPEN });
-  }
-  if (!isPositiveInt(status)) {
-    throw new AutotaskConfigError(`openWithNoteAndAssign: params.status must be a positive integer (got ${String(params.status)})`, { operation: OP_OPEN });
-  }
-  if (params.queueID !== void 0 && !isPositiveInt(params.queueID)) {
-    throw new AutotaskConfigError(`openWithNoteAndAssign: params.queueID must be a positive integer (got ${String(params.queueID)})`, { operation: OP_OPEN });
-  }
-  if (note !== void 0) {
-    if (typeof note.description !== "string" || note.description.trim() === "") {
-      throw new AutotaskConfigError("openWithNoteAndAssign: note.description is required (a non-empty string)", { operation: OP_OPEN });
-    }
-    if (typeof note.title !== "string" || note.title.trim() === "") {
-      throw new AutotaskConfigError("openWithNoteAndAssign: note.title is required (a non-empty string) \u2014 the ww29 scoped note create 500s without it (S12-A live-verified: Missing Required Field: title; the S11-B proven note body is { title, description, noteType: 1, publish: 1 })", { operation: OP_OPEN });
-    }
-    if (note.noteType !== void 0 && !isPositiveInt(note.noteType)) {
-      throw new AutotaskConfigError(`openWithNoteAndAssign: note.noteType must be a positive integer (got ${String(note.noteType)})`, { operation: OP_OPEN });
-    }
-    if (note.publish !== void 0 && !PUBLISH_VALUES.has(note.publish)) {
-      throw new AutotaskConfigError(`openWithNoteAndAssign: note.publish must be an integer picklist value 1/2/4 (got ${String(note.publish)} \u2014 NOT a boolean)`, { operation: OP_OPEN });
-    }
-  }
-  const assignee = assign === void 0 ? void 0 : parseIdentifier(assign.resourceID, "assign.resourceID");
-  if (assign !== void 0 && assignee !== void 0 && (typeof assignee === "number" ? assignee < 1 : false)) {
-    throw new AutotaskConfigError(`openWithNoteAndAssign: assign.resourceID must be a positive integer (got ${String(assignee)})`, { operation: OP_OPEN });
-  }
-  const roleID = assign?.roleID;
-  if (assign !== void 0 && !isPositiveInt(roleID)) {
-    throw new AutotaskConfigError("openWithNoteAndAssign: assign.roleID is required (a positive integer) \u2014 the ww29 vendor requires BOTH assignedResourceID and assignedResourceRoleID when assigning a resource (S12-A live-verified: Data violation: When assigning a Resource, you must assign both a assignedResourceID and assignedResourceRoleID)", { operation: OP_OPEN });
-  }
-  return { companyID, title, priority, status, assignee, roleID };
-}
-async function precheckAssignee(http, assignee, opts) {
-  const rid = assignee;
-  const rec = await fetchItem(http, `/V1.0/Resources/${rid}`, OP_OPEN, { maxRetries: opts.maxRetries });
-  if (rec === null) {
-    throw new TicketResourceInvalidError(
-      `openWithNoteAndAssign: assignee resource ${assignee} was not found (resources.get returned item: null \u2014 the resources table is blind to the API user; get is the authority)`,
-      { resourceIds: [rid], details: { idRefs: [{ entity: "resource", id: rid }] }, operation: OP_OPEN, category: "not_found", suggestedAction: "Resolve the resource id (a ticket assignedResourceID via tickets.fullContext) and retry." }
-    );
-  }
-  if (rec.isActive !== true) {
-    throw new TicketResourceInvalidError(
-      `openWithNoteAndAssign: assignee resource ${assignee} is not active (isActive !== true) \u2014 the vendor would reject the assignment`,
-      { resourceIds: [rid], details: { idRefs: [{ entity: "resource", id: rid }] }, operation: OP_OPEN, suggestedAction: "Activate the resource or assign an active one." }
-    );
-  }
-}
-function openDryRun(http, v, params, assign, body, noteBody) {
-  const { companyID, assignee, roleID } = v;
+function mergeDryRun(http, ticketId, targetStatus, guardDegraded, filled, mapEntry, mergeData) {
   const warnings = [];
-  if (params.queueID === void 0) {
-    warnings.push("queueID is omitted \u2014 the node NEVER guesses a queue: if the vendor 500 names it, the apply throws the typed QUEUE_REQUIRED (pass params.queueID \u2014 discover via autotask_describe(tickets.create)).");
+  if (guardDegraded) warnings.push(GUARD_DEGRADED_WARNING);
+  if (filled.length > 0) {
+    warnings.push(`the node will fill the map-required field(s) ${filled.join(", ")} with the proven-safe defaults (the live-discovered map); the caller value always wins.`);
   }
-  if (assign !== void 0) {
-    warnings.push(`the assignment is the v0.6.0 MERGE update (unredacted GET + collection PUT, 2 wire) setting assignedResourceID ${String(assignee)} + assignedResourceRoleID ${String(roleID)} (the vendor requires both \u2014 S12-A live-verified); a failure lands in steps[] as ASSIGN_FAILED (the applied ticketId is still returned).`);
+  if (mapEntry === void 0) {
+    warnings.push(`status ${targetStatus} has no entry in the live-discovered required-field map yet \u2014 if the vendor 500 names a required field without a safe default, the apply throws the typed STATUS_FIELDS_REQUIRED (the caller supplies the value; never a blind retry).`);
   }
   return buildDryRunResult(
     {
-      operation: OP_OPEN,
-      method: "POST",
+      operation: OP_STATUS,
+      method: "PUT",
       path: "/V1.0/Tickets",
-      ids: [companyID],
+      ids: [ticketId],
       checks: [
-        { name: "input-validation", ok: true },
-        { name: "assignee-active", ok: true }
+        { name: "status-known", ok: true },
+        { name: "merge-read", ok: true },
+        { name: "fields-resolved", ok: true }
       ],
-      impact: {
-        affected: 1 + (noteBody !== null ? 1 : 0) + (assign !== void 0 ? 1 : 0),
-        scope: "ticket (+ scoped note, + assignment merge)",
-        reversible: false
-      },
+      impact: { affected: 1, scope: "single-record", reversible: true },
       warnings,
-      data: {
-        ticket: body,
-        note: noteBody,
-        assign: assign !== void 0 ? { method: "GET+PUT", path: `/V1.0/Tickets/<newId>`, body: { assignedResourceID: assignee, assignedResourceRoleID: roleID } } : null
-      }
+      data: mergeData
     },
     { redactPersonalData: http.redactPersonalData }
   );
 }
-async function createTicketWithDiscovery(resource, params, companyID, body, steps) {
+async function putStatusWithDiscovery(http, ticketId, targetStatus, previousStatus, current, mergeData, mapEntry, filled, opts) {
+  const safeDefaults = mapEntry?.safeDefaults ?? {};
+  const body = mergePartialBody(current, mergeData);
+  body.id = ticketId;
   let merges = 0;
   for (; ; ) {
     try {
-      const created = await resource.create(body, {});
-      steps.push({ name: "create", ok: true });
-      return created.id;
+      await http.request({ method: "PUT", path: "/V1.0/Tickets", body, operation: OP_STATUS, maxRetries: opts.maxRetries });
+      return merges;
     } catch (err) {
       const named = namedVendorFields(err);
-      if (params.queueID === void 0 && named.includes("queueID")) {
-        const detail = vendorDetailOf(err);
-        throw new QueueRequiredError(
-          `openWithNoteAndAssign: the vendor rejected the ticket create naming 'queueID' (the ww29 live-required set is { title, status, priority, companyID, queueID }) and the node never guesses a queue${detail ? ` \u2014 ${detail}` : ""}`,
-          {
-            operation: OP_OPEN,
-            httpStatus: isAutotaskError(err) ? err.httpStatus : void 0,
-            vendorError: isAutotaskError(err) ? err.vendorError : void 0
-          }
-        );
-      }
-      const merge = discoveryMerge(err, body, SAFE_TICKET_CREATE_DEFAULTS);
+      const merge = discoveryMerge(err, body, safeDefaults);
       if (merge !== null && merges < MAX_DISCOVERY_MERGES) {
         body[merge.field] = merge.value;
+        if (!filled.includes(merge.field)) filled.push(merge.field);
         merges += 1;
         continue;
       }
-      throw new TicketCreateValidationFailedError(
-        `openWithNoteAndAssign: the vendor rejected the ticket create${named.length > 0 ? ` naming field(s) ${named.join(", ")}` : ""} (no proven-safe default \u2014 the discovery loop has no fill for a ticket create)${merges > 0 ? ` after ${merges} discovery merge(s)` : ""}`,
-        named,
-        {
-          operation: OP_OPEN,
-          httpStatus: isAutotaskError(err) ? err.httpStatus : void 0,
-          vendorError: isAutotaskError(err) ? err.vendorError : void 0,
-          resourceIds: [companyID],
-          details: { idRefs: [{ entity: "company", id: companyID }] }
-        }
-      );
+      if (named.length > 0 && named.every((f) => safeDefaults[f] === void 0)) {
+        const currentValues = {};
+        for (const f of named) currentValues[f] = current[f] ?? null;
+        throw new StatusFieldsRequiredError(
+          `changeStatus: the vendor rejected the status change ${previousStatus ?? "?"} \u2192 ${targetStatus} naming field(s) ${named.join(", ")} that have no proven-safe default \u2014 supply the value(s) in fields and retry (no blind retry)`,
+          { vendorFields: named, currentStatus: previousStatus, targetStatus, currentValues },
+          {
+            operation: OP_STATUS,
+            httpStatus: isAutotaskError(err) ? err.httpStatus : void 0,
+            vendorError: isAutotaskError(err) ? err.vendorError : void 0,
+            resourceIds: [ticketId],
+            details: { idRefs: [{ entity: "ticket", id: ticketId }] }
+          }
+        );
+      }
+      throw err;
     }
   }
 }
-async function createNoteStep(http, ticketId, noteBody, opts, steps) {
-  try {
-    const res = await http.request({ method: "POST", path: `/V1.0/Tickets/${ticketId}/Notes`, body: noteBody, operation: OP_OPEN, maxRetries: opts.maxRetries });
-    const noteId = operationId(res) ?? null;
-    steps.push({ name: "note", ok: true });
-    return noteId;
-  } catch (err) {
-    steps.push({ name: "note", ok: false, error: stepErrorText("NOTE_CREATE_FAILED", err) });
-    return null;
-  }
-}
-async function assignStep(http, ticketId, assignee, roleID, opts, steps) {
-  let assigned = false;
-  let ticketNumber = null;
-  try {
-    const current = await fetchItemUnredacted(http, `/V1.0/Tickets/${ticketId}`, OP_OPEN, { maxRetries: opts.maxRetries });
-    if (current === null) {
-      throw new NotFoundError(`openWithNoteAndAssign: ticket ${ticketId} vanished between the create and the assign merge read`, { operation: OP_OPEN, resourceIds: [ticketId], details: { idRefs: [{ entity: "ticket", id: ticketId }] } });
-    }
-    ticketNumber = typeof current.ticketNumber === "string" ? current.ticketNumber : null;
-    const merged = mergePartialBody(current, { id: ticketId, assignedResourceID: assignee, assignedResourceRoleID: roleID });
-    merged.id = ticketId;
-    await http.request({ method: "PUT", path: "/V1.0/Tickets", body: merged, operation: OP_OPEN, maxRetries: opts.maxRetries });
-    assigned = true;
-    steps.push({ name: "assign", ok: true });
-  } catch (err) {
-    steps.push({ name: "assign", ok: false, error: stepErrorText("ASSIGN_FAILED", err) });
-  }
-  return { assigned, ticketNumber };
-}
-async function openWithNoteAndAssign(resource, params, note, assign, opts, http) {
-  const validated = validateOpenInput(params, note, assign);
-  const { companyID, title, priority, status, assignee } = validated;
-  if (assign !== void 0 && assignee !== void 0) await precheckAssignee(http, assignee, opts);
-  const body = { title, status, priority, companyID };
-  if (params.queueID !== void 0) body.queueID = params.queueID;
-  const noteBody = note === void 0 ? null : {
-    title: note.title,
-    // REQUIRED by the vendor (S12-A live-verified: Missing Required Field: title)
-    description: note.description,
-    noteType: note.noteType ?? DEFAULT_NOTE_TYPE,
-    publish: note.publish ?? DEFAULT_PUBLISH
-  };
-  if (opts.dryRun === true) return openDryRun(http, validated, params, assign, body, noteBody);
-  const steps = [];
-  const ticketId = await createTicketWithDiscovery(resource, params, companyID, body, steps);
-  const noteId = noteBody !== null ? await createNoteStep(http, ticketId, noteBody, opts, steps) : null;
-  let assigned = false;
-  let ticketNumber = null;
-  if (assign !== void 0) ({ assigned, ticketNumber } = await assignStep(http, ticketId, assignee, validated.roleID, opts, steps));
-  return {
-    ticketId,
-    ticketNumber,
-    noteId,
-    assigned,
-    steps,
-    ...assign !== void 0 ? { blind: { resources: true, note: "the resources table is blind to this API user (count/query return 0) \u2014 the assignee was verified via resources.get (the authority)" } } : {}
-  };
-}
-
-// src/resources/special/tickets/changeStatus.ts
-var STATUS_REQUIRED_FIELDS = {
-  // <discovery output lands here — e.g. 8: { requiredFields: ['dueDateTime'], safeDefaults: { dueDateTime: '<now>' } }>
-};
-async function readLiveStatusSet(resource) {
-  const raw = await resource.getFieldInfo();
-  const row = raw.find((f) => f.name === "status");
-  const values = row !== void 0 && row.isPickList === true ? row.picklistValues : void 0;
-  const ids = /* @__PURE__ */ new Set();
-  if (Array.isArray(values)) {
-    for (const pv of values) {
-      const n = Number(pv.value);
-      if (Number.isFinite(n)) ids.add(n);
-    }
-  }
-  return ids;
-}
-var GUARD_DEGRADED_WARNING = "the tenant's live status picklist metadata was unavailable (the local guard is degraded for this call \u2014 the W-A4 wall or a metadata failure); the vendor's own validation is the final authority on the status value";
-async function guardTargetStatus(resource, http, targetStatus) {
-  let liveStatus = null;
-  try {
-    const ids = await readLiveStatusSet(resource);
-    if (ids.size > 0) liveStatus = ids;
-  } catch (err) {
-    if (!isAutotaskError(err) || err.code === "ABORTED") throw err;
-  }
-  if (liveStatus !== null && !liveStatus.has(targetStatus)) {
-    http.fieldCache?.invalidate("tickets:");
-    let freshStatus = null;
-    let reReadFailed = false;
-    try {
-      const freshIds = await readLiveStatusSet(resource);
-      if (freshIds.size > 0) freshStatus = freshIds;
-    } catch (err) {
-      if (!isAutotaskError(err) || err.code === "ABORTED") throw err;
-      freshStatus = null;
-      reReadFailed = true;
-    }
-    if (freshStatus !== null && freshStatus.has(targetStatus)) {
-      liveStatus = freshStatus;
-    } else {
-      const verdict = freshStatus ?? liveStatus;
-      const staleNote = freshStatus === null ? `; the live re-read ${reReadFailed ? "failed" : "returned no values"}, so this picklist count is from the initial read (up to one field-cache TTL old)` : "";
-      throw new StatusUnknownError(
-        `changeStatus: targetStatus ${targetStatus} is not in the tenant's live status picklist (live: ${verdict.size} values \u2014 the entity metadata is the oracle; the values + labels are discoverable with operations.fieldCatalog({ resources: ["tickets"], fields: ["status"], labels: true })${staleNote})`,
-        { operation: OP_STATUS, picklistCount: verdict.size }
-      );
-    }
-  }
-  return { guardDegraded: liveStatus === null };
-}
-function noChangeDryRun(http, ticketId, targetStatus, guardDegraded) {
-  return buildDryRunResult(
-    {
-      operation: OP_STATUS,
-      method: "PUT",
-      path: "/V1.0/Tickets",
-      ids: [ticketId],
-      checks: [
-        { name: "status-known", ok: true },
-        { name: "merge-read", ok: true },
-        { name: "no-op", ok: true }
-      ],
-      impact: { affected: 0, scope: "single-record", reversible: true },
-      warnings: [
-        ...guardDegraded ? [GUARD_DEGRADED_WARNING] : [],
-        `NO_CHANGE: the ticket is already in the target status ${targetStatus} \u2014 the apply would be a zero-wire no-op.`
-      ],
-      data: { reason: "NO_CHANGE", status: targetStatus }
-    },
-    { redactPersonalData: http.redactPersonalData }
-  );
-}
-function resolveMergeData(ticketId, targetStatus, previousStatus, current, fields, mapEntry) {
-  const mergeData = { status: targetStatus };
-  for (const [k, v] of Object.entries(fields ?? {})) {
-    if (v !== void 0) mergeData[k] = v;
-  }
-  const filled = [];
-  if (mapEntry !== void 0) {
-    for (const field of mapEntry.requiredFields) {
-      if (mergeData[field] !== void 0) continue;
-      if (current[field] !== null && current[field] !== void 0) continue;
-      const safe = mapEntry.safeDefaults?.[field];
-      if (safe === void 0) {
-        throw new StatusFieldsRequiredError(
-          `changeStatus: status ${targetStatus} requires the field '${field}' and the live-discovered map has no proven-safe default for it \u2014 the op is safe-without-the-map (never a blind full update): supply the value in fields and retry`,
-          { vendorFields: [field], currentStatus: previousStatus, targetStatus, currentValues: { [field]: current[field] ?? null } },
-          { operation: OP_STATUS, resourceIds: [ticketId], details: { idRefs: [{ entity: "ticket", id: ticketId }] } }
-        );
-      }
-      mergeData[field] = safe;
-      filled.push(field);
-    }
-  }
-  return { mergeData, filled };
-}
-function mergeDryRun(http, ticketId, targetStatus, guardDegraded, filled, mapEntry, mergeData) {
-  const warnings = [];
-  if (guardDegraded) warnings.push(GUARD_DEGRADED_WARNING);
-  if (filled.length > 0) {
-    warnings.push(`the node will fill the map-required field(s) ${filled.join(", ")} with the proven-safe defaults (the live-discovered map); the caller value always wins.`);
-  }
-  if (mapEntry === void 0) {
-    warnings.push(`status ${targetStatus} has no entry in the live-discovered required-field map yet \u2014 if the vendor 500 names a required field without a safe default, the apply throws the typed STATUS_FIELDS_REQUIRED (the caller supplies the value; never a blind retry).`);
-  }
-  return buildDryRunResult(
-    {
-      operation: OP_STATUS,
-      method: "PUT",
-      path: "/V1.0/Tickets",
-      ids: [ticketId],
-      checks: [
-        { name: "status-known", ok: true },
-        { name: "merge-read", ok: true },
-        { name: "fields-resolved", ok: true }
-      ],
-      impact: { affected: 1, scope: "single-record", reversible: true },
-      warnings,
-      data: mergeData
-    },
-    { redactPersonalData: http.redactPersonalData }
-  );
-}
-async function putStatusWithDiscovery(http, ticketId, targetStatus, previousStatus, current, mergeData, mapEntry, filled, opts) {
-  const safeDefaults = mapEntry?.safeDefaults ?? {};
-  const body = mergePartialBody(current, mergeData);
-  body.id = ticketId;
-  let merges = 0;
-  for (; ; ) {
-    try {
-      await http.request({ method: "PUT", path: "/V1.0/Tickets", body, operation: OP_STATUS, maxRetries: opts.maxRetries });
-      return merges;
-    } catch (err) {
-      const named = namedVendorFields(err);
-      const merge = discoveryMerge(err, body, safeDefaults);
-      if (merge !== null && merges < MAX_DISCOVERY_MERGES) {
-        body[merge.field] = merge.value;
-        if (!filled.includes(merge.field)) filled.push(merge.field);
-        merges += 1;
-        continue;
-      }
-      if (named.length > 0 && named.every((f) => safeDefaults[f] === void 0)) {
-        const currentValues = {};
-        for (const f of named) currentValues[f] = current[f] ?? null;
-        throw new StatusFieldsRequiredError(
-          `changeStatus: the vendor rejected the status change ${previousStatus ?? "?"} \u2192 ${targetStatus} naming field(s) ${named.join(", ")} that have no proven-safe default \u2014 supply the value(s) in fields and retry (no blind retry)`,
-          { vendorFields: named, currentStatus: previousStatus, targetStatus, currentValues },
-          {
-            operation: OP_STATUS,
-            httpStatus: isAutotaskError(err) ? err.httpStatus : void 0,
-            vendorError: isAutotaskError(err) ? err.vendorError : void 0,
-            resourceIds: [ticketId],
-            details: { idRefs: [{ entity: "ticket", id: ticketId }] }
-          }
-        );
-      }
-      throw err;
-    }
-  }
-}
-async function verifyStatusApplied(http, ticketId, targetStatus, opts) {
-  const verify = await fetchItem(http, `/V1.0/Tickets/${ticketId}`, OP_STATUS, { maxRetries: opts.maxRetries });
-  if (verify === null) {
-    throw new AutotaskError(`changeStatus: the post-PUT read-back found no ticket ${ticketId} (the PUT 200ed but the record is gone)`, {
-      code: "INVALID_RESPONSE",
-      category: "server",
-      operation: OP_STATUS,
-      resourceIds: [ticketId],
-      details: { idRefs: [{ entity: "ticket", id: ticketId }] }
-    });
+async function verifyStatusApplied(http, ticketId, targetStatus, opts) {
+  const verify = await fetchItem(http, `/V1.0/Tickets/${ticketId}`, OP_STATUS, { maxRetries: opts.maxRetries });
+  if (verify === null) {
+    throw new AutotaskError(`changeStatus: the post-PUT read-back found no ticket ${ticketId} (the PUT 200ed but the record is gone)`, {
+      code: "INVALID_RESPONSE",
+      category: "server",
+      operation: OP_STATUS,
+      resourceIds: [ticketId],
+      details: { idRefs: [{ entity: "ticket", id: ticketId }] }
+    });
   }
   const finalStatus = typeof verify.status === "number" ? verify.status : null;
   if (finalStatus !== targetStatus) {
@@ -8214,7 +8006,8 @@ async function verifyStatusApplied(http, ticketId, targetStatus, opts) {
     );
   }
 }
-async function changeStatus(resource, id, targetStatus, fields, opts, http) {
+async function changeStatus(resource, id, targetStatus, fields, opts) {
+  const http = resource.http;
   const ticketId = parseIdentifier(id, "id");
   if (!isPositiveInt(targetStatus)) {
     throw new AutotaskConfigError(`changeStatus: targetStatus must be a positive integer (got ${String(targetStatus)})`, { operation: OP_STATUS });
@@ -8240,199 +8033,78 @@ async function changeStatus(resource, id, targetStatus, fields, opts, http) {
   return { ticketId, previousStatus, status: targetStatus, changed: true, filledFields: filled, discoveryMerges: merges };
 }
 
-// src/resources/special/tickets/fullContext.ts
-var DEFAULT_PART_LIMIT = 50;
-function partLimit(value, name) {
-  const n = value === void 0 ? DEFAULT_PART_LIMIT : Math.trunc(value);
-  if (!Number.isInteger(n) || n < 1) {
-    throw new AutotaskConfigError(`fullContext: ${name} must be an integer >= 1 (got ${String(value)})`);
+// 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 COUNT_LINK_PAGES = 20;
+var TICKET_FIELDS = ["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;
 }
-function servedTextRecord(row, textField, limit) {
-  const text = row[textField];
-  if (typeof text !== "string" || text.length <= limit) return { ...row };
-  const out = { ...row };
-  out[`${textField}Truncated`] = true;
-  out[textField] = `${text.slice(0, limit)}\u2026`;
-  return out;
+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 addCompositeNames(http, ctx, entriesPart, result, opts) {
-  const builder = createNamePlan(TICKET_LABEL_FIELDS);
-  const t = ctx.ticket;
-  builder.addResource(t["creatorResourceID"]);
-  builder.addFk("contract", t["contractID"]);
-  builder.addFk("billingCode", t["billingCodeID"]);
-  builder.addFk("role", t["assignedResourceRoleID"]);
-  const ticketLobPointer = vendorId(t["organizationalLevelAssociationID"]);
-  if (ticketLobPointer !== void 0) {
-    builder.addLineOfBusiness(ticketLobPointer, { source: "ticket" });
-  } else {
-    builder.addLineOfBusinessFromContract(t["contractID"]);
+async function readLinkIds(http, resourceID, maxPages = 1) {
+  const ids = /* @__PURE__ */ new Set();
+  let cursor = null;
+  for (let pages = 0; pages < maxPages; pages++) {
+    const res = await http.request({
+      method: "POST",
+      idempotent: true,
+      path: cursor === null ? "/V1.0/TicketSecondaryResources/query" : cursorToPath(http.baseUrl, cursor),
+      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") ids.add(row.ticketID);
+    cursor = page.pageDetails.nextPageUrl;
+    if (cursor === null || page.items.length === 0) return { ids: [...ids], capped: false };
   }
-  for (const e of entriesPart.items) {
-    builder.addResource(e["resourceID"]);
-    builder.addFk("role", e["roleID"]);
-    builder.addFk("billingCode", e["billingCodeID"]);
-    builder.addFk("contract", e["contractID"]);
-  }
-  const names = await resolveCompositeNames(http, builder.plan(), { maxNameReads: opts.maxNameReads });
-  const ticketRow = { ...ctx.ticket };
-  addNameSibling(ticketRow, "creatorResourceID", (v) => names.resourceName(v));
-  addNameSibling(ticketRow, "contractID", (v) => names.recordName("contract", v));
-  addNameSibling(ticketRow, "billingCodeID", (v) => names.recordName("billingCode", v));
-  addNameSibling(ticketRow, "assignedResourceRoleID", (v) => names.recordName("role", v));
-  for (const f of TICKET_LABEL_FIELDS) addLabelSibling(ticketRow, f, names);
-  result.ticket = ticketRow;
-  result.timeEntries.items = entriesPart.items.map((e) => {
-    const row = { ...e };
-    addNameSibling(row, "resourceID", (v) => names.resourceName(v));
-    addNameSibling(row, "roleID", (v) => names.recordName("role", v));
-    addNameSibling(row, "billingCodeID", (v) => names.recordName("billingCode", v));
-    addNameSibling(row, "contractID", (v) => names.recordName("contract", v));
-    return row;
-  });
-  result.names = names.section;
-  result.lineOfBusiness = names.lineOfBusiness ?? {
-    association: null,
-    organizationalLevel2: null,
-    organizationalLevel1: null,
-    markers: { association: "missing", organizationalLevel2: "missing", organizationalLevel1: "missing" }
-  };
-  result.truncated = result.truncated || names.section.truncated;
-}
-async function fullContext(resource, id, opts = {}, http) {
-  const noteLimit = partLimit(opts.noteLimit, "noteLimit");
-  const timeEntryLimit = partLimit(opts.timeEntryLimit, "timeEntryLimit");
-  const textLimit = partLimit(opts.textLimit, "textLimit");
-  const ticketId = parseIdentifier(id, "id");
-  const ctx = await resource.getContext(ticketId);
-  const op = "tickets.fullContext";
-  const ticketFilter = [{ field: "ticketID", op: "eq", value: ticketId }];
-  const notes = await ticketChildRead(http, { globalPath: "/V1.0/TicketNotes/query", resourceKey: "ticket_notes", filter: ticketFilter, limit: noteLimit, operation: op }, ticketId);
-  const entries = await ticketChildRead(http, { globalPath: "/V1.0/TimeEntries/query", resourceKey: "time_entries", filter: ticketFilter, limit: timeEntryLimit, operation: op }, ticketId);
-  const notesRows = notes.items.map((n) => servedTextRecord(n, "description", textLimit));
-  const notesPart = { items: notesRows, capped: notes.capped };
-  applyRouteStatus(notesPart, notes);
-  const entriesPart = { items: entries.items, capped: entries.capped };
-  applyRouteStatus(entriesPart, entries);
-  const notesTextTruncated = notesRows.some((n) => n.descriptionTruncated === true);
-  let attachments = { ids: [], names: [], capped: false };
-  let attachmentsStatus = "ok";
-  if (opts.includeAttachments !== false) {
-    const read = await ticketChildRead(http, { globalPath: "/V1.0/TicketAttachments/query", resourceKey: "ticket_attachments", filter: ticketFilter, limit: DEFAULT_PART_LIMIT, operation: op }, ticketId);
-    attachmentsStatus = read.status;
-    attachments = {
-      ids: read.items.map((r) => Number(r.id)),
-      names: read.items.map((r) => typeof r.title === "string" ? r.title : null),
-      capped: read.capped
-    };
-    applyRouteStatus(attachments, read);
-  }
-  const result = {
-    ticket: ctx.ticket,
-    company: ctx.company,
-    contact: ctx.contact,
-    assignedResource: ctx.resource,
-    project: ctx.project,
-    notes: notesPart,
-    timeEntries: entriesPart,
-    attachments,
-    truncated: notesPart.capped || entriesPart.capped || attachments.capped || notesTextTruncated,
-    parts: {
-      company: ctx.company !== null ? "ok" : "absent",
-      contact: ctx.contact !== null ? "ok" : "absent",
-      assignedResource: ctx.resource !== null ? "ok" : "absent",
-      project: ctx.project !== null ? "ok" : "absent",
-      notes: notes.status,
-      timeEntries: entries.status,
-      attachments: attachmentsStatus
-    }
-  };
-  if (opts.includeHistories === true) {
-    const historiesRead = await ticketChildRead(http, { globalPath: "/V1.0/TicketHistory/query", resourceKey: "ticket_history", filter: ticketFilter, limit: DEFAULT_PART_LIMIT, operation: op }, ticketId);
-    const historyRows = historiesRead.items.map((h) => servedTextRecord(h, "detail", textLimit));
-    const part = { items: historyRows, capped: historiesRead.capped };
-    applyRouteStatus(part, historiesRead);
-    result.histories = part;
-    result.parts.histories = historiesRead.status;
-    result.truncated = result.truncated || part.capped || historyRows.some((h) => h.detailTruncated === true);
-  }
-  if (opts.names === true) await addCompositeNames(http, ctx, entriesPart, result, opts);
-  return result;
-}
-
-// src/resources/special/tickets/forResource.ts
-var OP2 = "tickets.forResource";
-var TICKET_CHUNK = 100;
-var LIMIT_DEFAULT = 100;
-var LIMIT_MAX = 500;
-var LINK_READ_CAP = 500;
-var COUNT_LINK_PAGES = 20;
-var TICKET_FIELDS = ["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(`${OP2}: ${name} must be a positive integer id (got ${String(value)})`, { operation: OP2 });
-  }
-  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: OP2
-  });
-  const page = unwrapItems(res, OP2);
-  return { rows: page.items, more: page.pageDetails.nextPageUrl !== null };
-}
-async function readLinkIds(http, resourceID, maxPages = 1) {
-  const ids = /* @__PURE__ */ new Set();
-  let cursor = null;
-  for (let pages = 0; pages < maxPages; pages++) {
-    const res = await http.request({
-      method: "POST",
-      idempotent: true,
-      path: cursor === null ? "/V1.0/TicketSecondaryResources/query" : cursorToPath(http.baseUrl, cursor),
-      body: { MaxRecords: LINK_READ_CAP, filter: [{ field: "resourceID", op: "eq", value: resourceID }], IncludeFields: ["ticketID"] },
-      operation: OP2
-    });
-    const page = unwrapItems(res, OP2);
-    for (const row of page.items) if (typeof row.ticketID === "number") ids.add(row.ticketID);
-    cursor = page.pageDetails.nextPageUrl;
-    if (cursor === null || page.items.length === 0) return { ids: [...ids], capped: false };
-  }
-  return { ids: [...ids], capped: true };
-}
-async function forResource(_resource, resourceIDIn, http, opts = {}) {
-  if (opts === null || typeof opts !== "object") throw new AutotaskConfigError(`${OP2}: opts must be an object`, { operation: OP2 });
-  const resourceID = positiveId(resourceIDIn, "resourceID");
-  const scope = opts.scope ?? "both";
-  if (scope !== "primary" && scope !== "secondary" && scope !== "both") {
-    throw new AutotaskConfigError(`${OP2}: scope must be 'primary', 'secondary' or 'both' (got ${JSON.stringify(opts.scope)})`, { operation: OP2 });
+  return { ids: [...ids], capped: true };
+}
+async function forResource(_resource, resourceIDIn, opts = {}) {
+  const http = _resource.http;
+  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(`${OP2}: openOnly must be a boolean`, { operation: OP2 });
+    throw new AutotaskConfigError(`${OP4}: openOnly must be a boolean`, { operation: OP4 });
   }
   const limit = opts.limit === void 0 ? LIMIT_DEFAULT : opts.limit;
   if (opts.countOnly !== true && (!Number.isInteger(limit) || limit < 1 || limit > LIMIT_MAX)) {
-    throw new AutotaskConfigError(`${OP2}: limit must be an integer 1-${LIMIT_MAX} (got ${String(opts.limit)})`, { operation: OP2 });
+    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(`${OP2}: includeFields must be a list of field names`, { operation: OP2 });
+    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_FIELDS, ...includeFields])];
   if (opts.countOnly !== void 0 && typeof opts.countOnly !== "boolean") {
-    throw new AutotaskConfigError(`${OP2}: countOnly must be a boolean`, { operation: OP2 });
+    throw new AutotaskConfigError(`${OP4}: countOnly must be a boolean`, { operation: OP4 });
   }
   const closed = await resolveTicketStatusSemantics(
     http,
     { ...opts.excludeStatusIds === void 0 ? {} : { excludeStatusIds: opts.excludeStatusIds }, ...opts.allowAssumed === void 0 ? {} : { allowAssumed: opts.allowAssumed } },
-    OP2
+    OP4
   );
   const closedStatus = { closedIds: closed.closedIds, source: closed.source, note: closed.note };
   const openLeaf = openOnly || opts.countOnly === true ? [openStatusFilter(closed.closedIds)] : [];
@@ -8519,74 +8191,483 @@ async function forResource(_resource, resourceIDIn, http, opts = {}) {
     closedStatus
   };
 }
-
-// src/resources/special/tickets/lineOfBusiness.ts
-var OP3 = "tickets.lineOfBusiness";
-function positiveId2(value, name) {
-  const n = typeof value === "string" && /^[0-9]+$/.test(value.trim()) ? Number(value) : value;
-  if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 1) {
-    throw new AutotaskConfigError(OP3 + ": " + name + " must be a positive integer id (got " + String(value) + ")", { operation: OP3 });
-  }
-  return n;
+
+// src/resources/special/tickets/common.ts
+async function fetchTicket(http, id, operation) {
+  const res = await http.request({
+    method: "GET",
+    path: `/V1.0/Tickets/${id}`,
+    operation
+  });
+  const body = res;
+  if (body === null || !("item" in body)) {
+    throw new NotFoundError(`Ticket ${id} not found (unexpected envelope shape)`, { resourceIds: [id], details: { idRefs: [{ entity: "ticket", id }] } });
+  }
+  if (body.item === null || body.item === void 0) throw new NotFoundError(`Ticket ${id} not found`, { resourceIds: [id], details: { idRefs: [{ entity: "ticket", id }] } });
+  return body.item;
+}
+async function ticketQueryItems(http, path, filter, maxRecords, operation) {
+  const res = await http.request({
+    method: "POST",
+    idempotent: true,
+    path,
+    body: { MaxRecords: maxRecords, filter },
+    operation
+  });
+  return unwrapItems(res).items;
+}
+function truncate(text, limit) {
+  const full = text ?? "";
+  if (full.length <= limit) return { value: full, truncated: false, length: full.length };
+  return { value: `${full.slice(0, limit)}\u2026`, truncated: true, length: full.length };
+}
+
+// src/resources/special/tickets/childRead.ts
+function isRouteUnavailable(err) {
+  return isAutotaskError(err) && (err.httpStatus === 404 || err.httpStatus === 500);
+}
+function routeFact(route, path, err) {
+  return {
+    route,
+    path,
+    httpStatus: isAutotaskError(err) && typeof err.httpStatus === "number" ? err.httpStatus : null
+  };
+}
+function childDeclaresQuery(resourceKey) {
+  return CAPABILITIES.some(
+    (c) => c.id === `${resourceKey}.query` && (c.status === "implemented" || c.status === "tested")
+  );
+}
+function planScopedPath(resourceKey, ticketId) {
+  if (!childDeclaresQuery(resourceKey)) return null;
+  const entry = RELATIONSHIP_MAP[resourceKey];
+  const parent = entry === void 0 ? null : entry.parent;
+  if (parent === null || parent.resource !== "tickets" || parent.segment === null || parent.field === null) return null;
+  const parentPath = RELATIONSHIP_MAP[parent.resource]?.path;
+  if (parentPath === null || parentPath === void 0) return null;
+  return `/V1.0/${parentPath}/${ticketId}/${parent.segment}`;
+}
+function scopedRowMatches(row, filter) {
+  let conds;
+  if (Array.isArray(filter)) conds = filter;
+  else if (filter !== null && typeof filter === "object" && Array.isArray(filter.filter)) {
+    conds = filter.filter;
+  }
+  if (conds === void 0) return true;
+  for (const raw of conds) {
+    if (raw === null || typeof raw !== "object") return false;
+    const cond = raw;
+    if (typeof cond.field !== "string" || typeof cond.op !== "string") return false;
+    if (cond.field === "ticketID") continue;
+    const value = row[cond.field];
+    if (typeof value !== "string") return false;
+    const want = String(cond.value ?? "");
+    if (cond.op === "eq" && value !== want) return false;
+    if (cond.op === "gt" && !(value > want)) return false;
+    if (cond.op === "lt" && !(value < want)) return false;
+    if (cond.op !== "eq" && cond.op !== "gt" && cond.op !== "lt") return false;
+  }
+  return true;
+}
+var SCOPED_FALLBACK_PAGE_CAP = 10;
+async function scopedCollectionRead(http, startPath, limit, operation, accept) {
+  let target = startPath;
+  const items = [];
+  let guard = false;
+  let pages = 0;
+  let nextCursor = null;
+  for (; ; ) {
+    if (pages >= SCOPED_FALLBACK_PAGE_CAP) {
+      guard = true;
+      break;
+    }
+    const body = await http.request({ method: "GET", path: target, operation });
+    const { items: pageItems, pageDetails } = unwrapItems(body, operation);
+    nextCursor = pageDetails.nextPageUrl;
+    pages += 1;
+    const window = pageItems.slice(0, Math.max(0, limit - items.length));
+    for (const row of window) if (accept(row)) items.push(row);
+    if (items.length >= limit) break;
+    if (nextCursor === null || pageItems.length === 0) break;
+    target = cursorToPath(http.baseUrl, nextCursor);
+  }
+  const capped = items.length >= limit || guard && nextCursor !== null;
+  return { items, capped };
+}
+async function ticketChildRead(http, spec, ticketId) {
+  try {
+    const items = await ticketQueryItems(http, spec.globalPath, spec.filter, spec.limit, spec.operation);
+    return { items, capped: items.length >= spec.limit, status: "ok", routeFacts: [] };
+  } catch (err) {
+    if (!isRouteUnavailable(err)) throw err;
+    const facts = [routeFact("global", spec.globalPath, err)];
+    const scopedPath = planScopedPath(spec.resourceKey, ticketId);
+    if (scopedPath === null) return { items: [], capped: false, status: "miss", routeFacts: facts };
+    try {
+      const read = await scopedCollectionRead(http, scopedPath, spec.limit, spec.operation, (row) => scopedRowMatches(row, spec.filter));
+      return { ...read, status: "ok-scoped", routeFacts: [] };
+    } catch (scopedErr) {
+      facts.push(routeFact("scoped", scopedPath, scopedErr));
+      return { items: [], capped: false, status: "miss", routeFacts: facts };
+    }
+  }
+}
+function applyRouteStatus(part, read) {
+  if (read.status === "ok-scoped") part.route = "scoped";
+  if (read.status === "miss") part.routeFacts = read.routeFacts;
+}
+
+// src/resources/special/tickets/fullContext.ts
+var DEFAULT_PART_LIMIT = 50;
+function partLimit(value, name) {
+  const n = value === void 0 ? DEFAULT_PART_LIMIT : Math.trunc(value);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new AutotaskConfigError(`fullContext: ${name} must be an integer >= 1 (got ${String(value)})`);
+  }
+  return n;
+}
+function servedTextRecord(row, textField, limit) {
+  const text = row[textField];
+  if (typeof text !== "string" || text.length <= limit) return { ...row };
+  const out = { ...row };
+  out[`${textField}Truncated`] = true;
+  out[textField] = `${text.slice(0, limit)}\u2026`;
+  return out;
+}
+async function addCompositeNames(http, ctx, entriesPart, result, opts) {
+  const builder = createNamePlan(TICKET_LABEL_FIELDS);
+  const t = ctx.ticket;
+  builder.addResource(t["creatorResourceID"]);
+  builder.addFk("contract", t["contractID"]);
+  builder.addFk("billingCode", t["billingCodeID"]);
+  builder.addFk("role", t["assignedResourceRoleID"]);
+  const ticketLobPointer = vendorId(t["organizationalLevelAssociationID"]);
+  if (ticketLobPointer !== void 0) {
+    builder.addLineOfBusiness(ticketLobPointer, { source: "ticket" });
+  } else {
+    builder.addLineOfBusinessFromContract(t["contractID"]);
+  }
+  for (const e of entriesPart.items) {
+    builder.addResource(e["resourceID"]);
+    builder.addFk("role", e["roleID"]);
+    builder.addFk("billingCode", e["billingCodeID"]);
+    builder.addFk("contract", e["contractID"]);
+  }
+  const names = await resolveCompositeNames(http, builder.plan(), { maxNameReads: opts.maxNameReads });
+  const ticketRow = { ...ctx.ticket };
+  addNameSibling(ticketRow, "creatorResourceID", (v) => names.resourceName(v));
+  addNameSibling(ticketRow, "contractID", (v) => names.recordName("contract", v));
+  addNameSibling(ticketRow, "billingCodeID", (v) => names.recordName("billingCode", v));
+  addNameSibling(ticketRow, "assignedResourceRoleID", (v) => names.recordName("role", v));
+  for (const f of TICKET_LABEL_FIELDS) addLabelSibling(ticketRow, f, names);
+  result.ticket = ticketRow;
+  result.timeEntries.items = entriesPart.items.map((e) => {
+    const row = { ...e };
+    addNameSibling(row, "resourceID", (v) => names.resourceName(v));
+    addNameSibling(row, "roleID", (v) => names.recordName("role", v));
+    addNameSibling(row, "billingCodeID", (v) => names.recordName("billingCode", v));
+    addNameSibling(row, "contractID", (v) => names.recordName("contract", v));
+    return row;
+  });
+  result.names = names.section;
+  result.lineOfBusiness = names.lineOfBusiness ?? {
+    association: null,
+    organizationalLevel2: null,
+    organizationalLevel1: null,
+    markers: { association: "missing", organizationalLevel2: "missing", organizationalLevel1: "missing" }
+  };
+  result.truncated = result.truncated || names.section.truncated;
+}
+async function fullContext(resource, id, opts = {}) {
+  const http = resource.http;
+  const noteLimit = partLimit(opts.noteLimit, "noteLimit");
+  const timeEntryLimit = partLimit(opts.timeEntryLimit, "timeEntryLimit");
+  const textLimit = partLimit(opts.textLimit, "textLimit");
+  const ticketId = parseIdentifier(id, "id");
+  const ctx = await resource.getContext(ticketId);
+  const op = "tickets.fullContext";
+  const ticketFilter = [{ field: "ticketID", op: "eq", value: ticketId }];
+  const notes = await ticketChildRead(http, { globalPath: "/V1.0/TicketNotes/query", resourceKey: "ticket_notes", filter: ticketFilter, limit: noteLimit, operation: op }, ticketId);
+  const entries = await ticketChildRead(http, { globalPath: "/V1.0/TimeEntries/query", resourceKey: "time_entries", filter: ticketFilter, limit: timeEntryLimit, operation: op }, ticketId);
+  const notesRows = notes.items.map((n) => servedTextRecord(n, "description", textLimit));
+  const notesPart = { items: notesRows, capped: notes.capped };
+  applyRouteStatus(notesPart, notes);
+  const entriesPart = { items: entries.items, capped: entries.capped };
+  applyRouteStatus(entriesPart, entries);
+  const notesTextTruncated = notesRows.some((n) => n.descriptionTruncated === true);
+  let attachments = { ids: [], names: [], capped: false };
+  let attachmentsStatus = "ok";
+  if (opts.includeAttachments !== false) {
+    const read = await ticketChildRead(http, { globalPath: "/V1.0/TicketAttachments/query", resourceKey: "ticket_attachments", filter: ticketFilter, limit: DEFAULT_PART_LIMIT, operation: op }, ticketId);
+    attachmentsStatus = read.status;
+    attachments = {
+      ids: read.items.map((r) => Number(r.id)),
+      names: read.items.map((r) => typeof r.title === "string" ? r.title : null),
+      capped: read.capped
+    };
+    applyRouteStatus(attachments, read);
+  }
+  const result = {
+    ticket: ctx.ticket,
+    company: ctx.company,
+    contact: ctx.contact,
+    assignedResource: ctx.resource,
+    project: ctx.project,
+    notes: notesPart,
+    timeEntries: entriesPart,
+    attachments,
+    truncated: notesPart.capped || entriesPart.capped || attachments.capped || notesTextTruncated,
+    parts: {
+      company: ctx.company !== null ? "ok" : "absent",
+      contact: ctx.contact !== null ? "ok" : "absent",
+      assignedResource: ctx.resource !== null ? "ok" : "absent",
+      project: ctx.project !== null ? "ok" : "absent",
+      notes: notes.status,
+      timeEntries: entries.status,
+      attachments: attachmentsStatus
+    }
+  };
+  if (opts.includeHistories === true) {
+    const historiesRead = await ticketChildRead(http, { globalPath: "/V1.0/TicketHistory/query", resourceKey: "ticket_history", filter: ticketFilter, limit: DEFAULT_PART_LIMIT, operation: op }, ticketId);
+    const historyRows = historiesRead.items.map((h) => servedTextRecord(h, "detail", textLimit));
+    const part = { items: historyRows, capped: historiesRead.capped };
+    applyRouteStatus(part, historiesRead);
+    result.histories = part;
+    result.parts.histories = historiesRead.status;
+    result.truncated = result.truncated || part.capped || historyRows.some((h) => h.detailTruncated === true);
+  }
+  if (opts.names === true) await addCompositeNames(http, ctx, entriesPart, result, opts);
+  return result;
+}
+
+// src/resources/special/tickets/lineOfBusiness.ts
+var OP5 = "tickets.lineOfBusiness";
+function positiveId2(value, name) {
+  const n = typeof value === "string" && /^[0-9]+$/.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 });
+  }
+  return n;
+}
+async function lineOfBusiness(resource, ticketIdIn, associationIdIn) {
+  const http = resource.http;
+  const ticketId = positiveId2(ticketIdIn, "ticketId");
+  let associationId;
+  let associationSource = null;
+  let contractId = null;
+  let contractUnread = false;
+  if (associationIdIn !== void 0) {
+    associationId = positiveId2(associationIdIn, "associationId");
+    associationSource = "argument";
+  } else {
+    const ticket = await resource.get(ticketId);
+    associationId = vendorId(ticket.organizationalLevelAssociationID);
+    if (associationId !== void 0) {
+      associationSource = "ticket";
+    } else {
+      const contractRef = vendorId(ticket.contractID);
+      if (contractRef !== void 0) {
+        const client = http.client;
+        if (client === void 0) {
+          throw new AutotaskConfigError(OP5 + ": the transport is not wired to an AutotaskClient (the composite must run through the client)", { operation: OP5 });
+        }
+        try {
+          const contract = await client.contracts.get(contractRef);
+          contractId = contractRef;
+          associationId = vendorId(contract.organizationalLevelAssociationID);
+          if (associationId !== void 0) associationSource = "contract";
+        } catch (e) {
+          if (e instanceof NotFoundError) {
+            contractId = contractRef;
+          } else if (isAutotaskError(e) && e.code !== "ABORTED") {
+            contractId = contractRef;
+            contractUnread = true;
+          } else {
+            throw e;
+          }
+        }
+      }
+    }
+  }
+  if (associationId === void 0) {
+    return {
+      ticketId,
+      associationSource,
+      contractId,
+      association: null,
+      organizationalLevel2: null,
+      organizationalLevel1: null,
+      markers: { association: contractUnread ? "unresolved" : "missing", organizationalLevel2: "missing", organizationalLevel1: "missing" }
+    };
+  }
+  const chain = await resolveLineOfBusinessChain(http, associationId, { budget: 3, operation: OP5, onError: "propagate" });
+  const { association, organizationalLevel2, organizationalLevel1, markers } = chain.lineOfBusiness;
+  return { ticketId, associationSource, contractId, association, organizationalLevel2, organizationalLevel1, markers };
+}
+
+// src/resources/special/tickets/sla.ts
+var MS = 864e5;
+var SLA_PAGE = 100;
+async function slaHealthCheck(_resource, id, opts = {}) {
+  const http = _resource.http;
+  void opts;
+  const ticketId = parseIdentifier(id, "id");
+  await fetchTicket(http, ticketId, "tickets.slaHealthCheck");
+  const rows = await ticketQueryItems(
+    http,
+    "/V1.0/ServiceLevelAgreementResults/query",
+    [{ field: "ticketID", op: "eq", value: ticketId }],
+    SLA_PAGE,
+    "tickets.slaHealthCheck"
+  );
+  const slas = rows.map((row) => {
+    const bool = (v) => typeof v === "boolean" ? v : null;
+    const num = (v) => typeof v === "number" ? v : null;
+    const milestones = [
+      { name: "firstResponse", met: bool(row.isFirstResponseMet), elapsedHours: num(row.firstResponseElapsedHours) },
+      { name: "resolution", met: bool(row.isResolutionMet), elapsedHours: num(row.resolutionElapsedHours) },
+      { name: "resolutionPlan", met: bool(row.isResolutionPlanMet), elapsedHours: num(row.resolutionPlanElapsedHours) }
+    ];
+    return { id: Number(row.id), name: row.serviceLevelAgreementName ?? null, milestones };
+  });
+  const healthy = slas.every((sla) => sla.milestones.every((m) => m.met === true));
+  return { ticketId, slaCount: slas.length, healthy, slas, truncated: rows.length >= SLA_PAGE };
+}
+async function summary(_resource, id, opts = {}) {
+  const http = _resource.http;
+  const limit = opts.summaryTextLimit === void 0 ? 500 : Math.trunc(opts.summaryTextLimit);
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new AutotaskConfigError(`summaryTextLimit must be an integer >= 1 (got ${String(opts.summaryTextLimit)})`);
+  }
+  const ticketId = parseIdentifier(id, "id");
+  const ticket = await fetchTicket(http, ticketId, "tickets.summary");
+  const desc = truncate(ticket.description, limit);
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const ageDays = typeof ticket.createDate === "string" && ticket.createDate !== "" ? Math.max(0, Math.floor((now.getTime() - Date.parse(ticket.createDate)) / MS)) : null;
+  const pick = (v) => typeof v === "number" ? v : null;
+  const str = (v) => typeof v === "string" && v !== "" ? v : null;
+  return {
+    ticketId,
+    ticketNumber: str(ticket.ticketNumber),
+    title: str(ticket.title),
+    description: desc.value,
+    descriptionLength: desc.length,
+    descriptionTruncated: desc.truncated,
+    status: pick(ticket.status),
+    priority: pick(ticket.priority),
+    companyID: pick(ticket.companyID),
+    contactID: pick(ticket.contactID),
+    assignedResourceID: pick(ticket.assignedResourceID),
+    projectID: pick(ticket.projectID),
+    createDate: str(ticket.createDate),
+    dueDateTime: str(ticket.dueDateTime),
+    ageDays
+  };
+}
+
+// src/resources/special/tickets/statusSemantics.ts
+async function statusSemantics(_resource, opts = {}) {
+  const http = _resource.http;
+  return resolveTicketStatusSemantics(http, opts);
+}
+
+// src/resources/special/tickets/timeline.ts
+function validateTimelineLimits(opts) {
+  const limit = opts.limit === void 0 ? 100 : Math.trunc(opts.limit);
+  if (!Number.isInteger(limit) || limit < 1) throw new AutotaskConfigError(`limit must be an integer >= 1 (got ${String(opts.limit)})`);
+  const bounded = Math.min(limit, 500);
+  const textLimit = opts.textLimit === void 0 ? 500 : Math.trunc(opts.textLimit);
+  if (!Number.isInteger(textLimit) || textLimit < 1) {
+    throw new AutotaskConfigError(`textLimit must be an integer >= 1 (got ${String(opts.textLimit)})`);
+  }
+  return { bounded, textLimit };
+}
+function noteEvent(n, textLimit) {
+  const text = truncate(typeof n.description === "string" ? n.description : null, textLimit);
+  return {
+    kind: "note",
+    id: Number(n.id),
+    date: typeof n.createDateTime === "string" ? n.createDateTime : null,
+    text: text.value || null,
+    title: typeof n.title === "string" ? n.title : null,
+    hours: null,
+    action: null,
+    textTruncated: text.truncated
+  };
+}
+function timeEntryEvent(t) {
+  return {
+    kind: "timeEntry",
+    id: Number(t.id),
+    date: typeof t.dateWorked === "string" ? t.dateWorked : null,
+    text: null,
+    title: null,
+    hours: typeof t.hoursWorked === "number" ? t.hoursWorked : null,
+    action: null,
+    textTruncated: false
+  };
+}
+function historyEvent(h, textLimit) {
+  const text = truncate(typeof h.detail === "string" ? h.detail : null, textLimit);
+  return {
+    kind: "history",
+    id: Number(h.id),
+    date: typeof h.date === "string" ? h.date : null,
+    text: text.value || null,
+    title: null,
+    hours: null,
+    action: typeof h.action === "string" ? h.action : null,
+    textTruncated: text.truncated
+  };
 }
-async function lineOfBusiness(resource, ticketIdIn, http, associationIdIn) {
-  const ticketId = positiveId2(ticketIdIn, "ticketId");
-  let associationId;
-  let associationSource = null;
-  let contractId = null;
-  let contractUnread = false;
-  if (associationIdIn !== void 0) {
-    associationId = positiveId2(associationIdIn, "associationId");
-    associationSource = "argument";
-  } else {
-    const ticket = await resource.get(ticketId);
-    associationId = vendorId(ticket.organizationalLevelAssociationID);
-    if (associationId !== void 0) {
-      associationSource = "ticket";
-    } else {
-      const contractRef = vendorId(ticket.contractID);
-      if (contractRef !== void 0) {
-        const client = http.client;
-        if (client === void 0) {
-          throw new AutotaskConfigError(OP3 + ": the transport is not wired to an AutotaskClient (the composite must run through the client)", { operation: OP3 });
-        }
-        try {
-          const contract = await client.contracts.get(contractRef);
-          contractId = contractRef;
-          associationId = vendorId(contract.organizationalLevelAssociationID);
-          if (associationId !== void 0) associationSource = "contract";
-        } catch (e) {
-          if (e instanceof NotFoundError) {
-            contractId = contractRef;
-          } else if (isAutotaskError(e) && e.code !== "ABORTED") {
-            contractId = contractRef;
-            contractUnread = true;
-          } else {
-            throw e;
-          }
-        }
-      }
-    }
+function compareEventDates(a, b) {
+  const da = a.date ?? "";
+  const db = b.date ?? "";
+  if (da === "" && db === "") return 0;
+  if (da === "") return 1;
+  if (db === "") return -1;
+  return da < db ? -1 : da > db ? 1 : 0;
+}
+async function timeline(_resource, id, opts = {}) {
+  const http = _resource.http;
+  const { bounded, textLimit } = validateTimelineLimits(opts);
+  const ticketId = parseIdentifier(id, "id");
+  await fetchTicket(http, ticketId, "tickets.timeline");
+  const dateFilters = (field) => {
+    const f = [{ field: "ticketID", op: "eq", value: ticketId }];
+    if (opts.since !== void 0) f.push({ field, op: "gt", value: opts.since });
+    if (opts.until !== void 0) f.push({ field, op: "lt", value: opts.until });
+    return f;
+  };
+  const events = [];
+  const cappedSources = [];
+  const notes = await ticketChildRead(http, { globalPath: "/V1.0/TicketNotes/query", resourceKey: "ticket_notes", filter: dateFilters("createDateTime"), limit: bounded, operation: "tickets.timeline" }, ticketId);
+  if (notes.capped) cappedSources.push("notes");
+  for (const n of notes.items) events.push(noteEvent(n, textLimit));
+  const entries = await ticketChildRead(http, { globalPath: "/V1.0/TimeEntries/query", resourceKey: "time_entries", filter: dateFilters("dateWorked"), limit: bounded, operation: "tickets.timeline" }, ticketId);
+  if (entries.capped) cappedSources.push("timeEntries");
+  for (const t of entries.items) events.push(timeEntryEvent(t));
+  let historiesRead;
+  if (opts.includeHistories) {
+    historiesRead = await ticketChildRead(http, { globalPath: "/V1.0/TicketHistory/query", resourceKey: "ticket_history", filter: dateFilters("date"), limit: bounded, operation: "tickets.timeline" }, ticketId);
+    if (historiesRead.capped) cappedSources.push("histories");
+    for (const h of historiesRead.items) events.push(historyEvent(h, textLimit));
   }
-  if (associationId === void 0) {
-    return {
-      ticketId,
-      associationSource,
-      contractId,
-      association: null,
-      organizationalLevel2: null,
-      organizationalLevel1: null,
-      markers: { association: contractUnread ? "unresolved" : "missing", organizationalLevel2: "missing", organizationalLevel1: "missing" }
-    };
+  events.sort(compareEventDates);
+  const capped = events.slice(0, bounded);
+  const result = {
+    ticketId,
+    count: capped.length,
+    events: capped,
+    truncated: cappedSources.length > 0 || events.length > bounded,
+    cappedSources
+  };
+  if (notes.status !== "ok" || entries.status !== "ok" || historiesRead !== void 0 && historiesRead.status !== "ok") {
+    const routes = { notes: notes.status, timeEntries: entries.status };
+    if (historiesRead !== void 0) routes.histories = historiesRead.status;
+    result.sourceRoutes = routes;
   }
-  const chain = await resolveLineOfBusinessChain(http, associationId, { budget: 3, operation: OP3, onError: "propagate" });
-  const { association, organizationalLevel2, organizationalLevel1, markers } = chain.lineOfBusiness;
-  return { ticketId, associationSource, contractId, association, organizationalLevel2, organizationalLevel1, markers };
-}
-
-// src/resources/special/tickets/statusSemantics.ts
-async function statusSemantics(_resource, opts = {}, http) {
-  return resolveTicketStatusSemantics(http, opts);
+  return result;
 }
 
 // src/resources/tickets.ts
@@ -8670,40 +8751,36 @@ var TicketsResource = class extends BaseResource {
     const project = await this.contextFetch("/V1.0/Projects", root["projectID"]);
     return { ticket, company, contact, resource, project };
   }
-  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  /** Node-parity special op (hand-written in src/resources/special/tickets/changeStatus.ts). */
   changeStatus(id, targetStatus, fields, opts = {}) {
-    return changeStatus(this, id, targetStatus, fields, opts, this.http);
-  }
-  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
-  openWithNoteAndAssign(params, note, assign, opts = {}) {
-    return openWithNoteAndAssign(this, params, note, assign, opts, this.http);
+    return changeStatus(this, id, targetStatus, fields, opts);
   }
-  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  /** Node-parity special op (hand-written in src/resources/special/tickets/sla.ts). */
   slaHealthCheck(id, opts) {
-    return slaHealthCheck(this, id, opts, this.http);
+    return slaHealthCheck(this, id, opts);
   }
-  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  /** Node-parity special op (hand-written in src/resources/special/tickets/sla.ts). */
   summary(id, opts) {
-    return summary(this, id, opts, this.http);
+    return summary(this, id, opts);
   }
-  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  /** Node-parity special op (hand-written in src/resources/special/tickets/timeline.ts). */
   timeline(id, opts) {
-    return timeline(this, id, opts, this.http);
+    return timeline(this, id, opts);
   }
-  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  /** Node-parity special op (hand-written in src/resources/special/tickets/fullContext.ts). */
   fullContext(id, opts) {
-    return fullContext(this, id, opts, this.http);
+    return fullContext(this, id, opts);
   }
-  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  /** Node-parity special op (hand-written in src/resources/special/tickets/statusSemantics.ts). */
   statusSemantics(opts) {
-    return statusSemantics(this, opts, this.http);
+    return statusSemantics(this, opts);
   }
   forResource(resourceID, opts) {
-    return forResource(this, resourceID, this.http, opts);
+    return forResource(this, resourceID, opts);
   }
-  /** Node-parity special op (hand-written in src/resources/special/tickets.ts). */
+  /** Node-parity special op (hand-written in src/resources/special/tickets/lineOfBusiness.ts). */
   lineOfBusiness(ticketId, associationId) {
-    return lineOfBusiness(this, ticketId, this.http, associationId);
+    return lineOfBusiness(this, ticketId, associationId);
   }
 };
 
@@ -8783,6 +8860,356 @@ var TicketWebhooksResource = class extends BaseResource {
   }
 };
 
+// src/resources/special/time_entries/move.ts
+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: OP6, maxRetries: retries });
+    return res?.item ?? null;
+  } catch (e) {
+    if (isAutotaskError(e) && (e.httpStatus === 404 || e.code === "NOT_FOUND")) return null;
+    throw e;
+  }
+}
+async function checkSource2({ http, source, sourceId, toTicketId, retries }) {
+  const ids = { sourceId, toTicketId };
+  if (source.taskID !== null && source.taskID !== void 0) {
+    throw refuse("MOVE_SOURCE_UNSUPPORTED", `${OP6}: time entry ${sourceId} is on a task \u2014 only ticket time entries are moved`, ids, OP6);
+  }
+  if (source.billingApprovalDateTime || source.billingApprovalResourceID || source.billingApprovalLevelMostRecent) {
+    throw refuse("MOVE_BLOCKED_APPROVED", `${OP6}: time entry ${sourceId} has billing approval set \u2014 move it in the Autotask UI`, ids, 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 }], OP6, retries);
+  } catch {
+    throw refuse("MOVE_BLOCKED_BILLED", `${OP6}: the billing items of time entry ${sourceId} could not be read \u2014 refused (fails closed)`, ids, 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", `${OP6}: time entry ${sourceId} is billed or posted \u2014 move it in the Autotask UI`, ids, 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 }], OP6, retries);
+  if (attachments.length > 0) {
+    throw refuse("MOVE_BLOCKED_ATTACHMENTS", `${OP6}: time entry ${sourceId} has attachments, which a delete would destroy \u2014 move it in the Autotask UI`, ids, OP6, { manualAction: { action: "delete_source", uiLink: uiLinkFor(http, "time_entries", sourceId), reason: "entries with attachments are not moved by the API" } });
+  }
+}
+var SPEC2 = {
+  operation: OP6,
+  entity: "time_entry",
+  readSource: readTimeEntry,
+  sourceTicketId: (s) => typeof s.ticketID === "number" ? s.ticketID : null,
+  dateField: "dateWorked",
+  checkSource: checkSource2,
+  buildPayload(source, toTicketId, { sameScope }) {
+    const body = { ticketID: toTicketId };
+    for (const k of COPY2) if (source[k] !== void 0 && source[k] !== null) body[k] = source[k];
+    if (sameScope) {
+      for (const k of CONTRACT_SCOPED2) if (source[k] !== void 0 && source[k] !== null) body[k] = source[k];
+    }
+    return body;
+  },
+  createPath: () => "/V1.0/TimeEntries",
+  deletePath: (id) => `/V1.0/TimeEntries/${id}`,
+  readById: (http, id) => readTimeEntry(http, id),
+  verifyFields: ["resourceID", "roleID", "billingCodeID", "dateWorked", "startDateTime", "endDateTime", "hoursWorked", "summaryNotes", "internalNotes", "isNonBillable"],
+  guardFields: ["ticketID", "resourceID", "roleID", "dateWorked", "startDateTime", "endDateTime", "hoursWorked", "summaryNotes", "billingApprovalDateTime", "billingApprovalResourceID", "lastModifiedDateTime"],
+  twinQuery: (p) => ({
+    resource: "TimeEntries",
+    filter: [
+      { field: "ticketID", op: "eq", value: p.ticketID },
+      { field: "resourceID", op: "eq", value: p.resourceID },
+      { field: "dateWorked", op: "eq", value: p.dateWorked },
+      { field: "hoursWorked", op: "eq", value: p.hoursWorked }
+    ]
+  }),
+  manualLink: (http, source) => uiLinkFor(http, "time_entries", Number(source.id))
+};
+function moveToTicket2(resource, sourceId, toTicketId, opts) {
+  return runMove(resource.http, SPEC2, sourceId, toTicketId, opts);
+}
+
+// src/resources/special/time_entries/posted.ts
+async function postedStateOf(http, entries, op, beforeRequest) {
+  const states = /* @__PURE__ */ new Map();
+  const ids = [...new Set(entries.map((e) => e.id))];
+  let incomplete = false;
+  for (let c = 0; c < ids.length; c += FETCH_BY_IDS_CHUNK_SIZE) {
+    const chunk = ids.slice(c, c + FETCH_BY_IDS_CHUNK_SIZE);
+    beforeRequest?.();
+    const res = await http.request({
+      method: "POST",
+      idempotent: true,
+      path: "/V1.0/BillingItems/query",
+      body: { MaxRecords: 500, IncludeFields: ["id", "timeEntryID"], filter: [{ field: "timeEntryID", op: "in", value: chunk }] },
+      operation: op
+    });
+    const { items, pageDetails } = unwrapItems(res);
+    const billed = new Set(items.map((i) => i.timeEntryID));
+    const more = pageDetails.nextPageUrl != null;
+    if (more) incomplete = true;
+    for (const id of chunk) {
+      if (billed.has(id)) states.set(id, "posted");
+      else if (!more) states.set(id, "unposted");
+    }
+  }
+  return { states, incomplete };
+}
+
+// src/resources/special/time_entries/windows.ts
+var DAY_MS = 864e5;
+var PAGE = 500;
+var COUNT_BUDGET_DEFAULT = 30;
+var COUNT_BUDGET_MAX = 200;
+var CURSOR_MAX = 2048;
+var YMD_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function ymdDayMs(value, label, OP7) {
+  const m = YMD_RE.exec(value.trim());
+  if (!m) {
+    throw new AutotaskConfigError(`${OP7}: ${label} must be a UTC 'YYYY-MM-DD' date (got ${JSON.stringify(value)})`, { operation: OP7 });
+  }
+  const y = Number(m[1]);
+  const mo = Number(m[2]);
+  const d = Number(m[3]);
+  const probe = new Date(Date.UTC(y, mo - 1, d));
+  if (probe.getUTCFullYear() !== y || probe.getUTCMonth() !== mo - 1 || probe.getUTCDate() !== d) {
+    throw new AutotaskConfigError(`${OP7}: ${label} is not a valid UTC date (${JSON.stringify(value)})`, { operation: OP7 });
+  }
+  return Date.UTC(y, mo - 1, d);
+}
+function windowBounds(from, to, OP7) {
+  const fromMs = ymdDayMs(from, "from", OP7);
+  const toMs = ymdDayMs(to, "to", OP7);
+  if (fromMs > toMs) {
+    throw new AutotaskConfigError(`${OP7}: from (${from}) must not be after to (${to})`, { operation: OP7 });
+  }
+  return { fromMs, toMs };
+}
+var iso = (ms) => new Date(ms).toISOString().slice(0, 19) + "Z";
+var ENTRY_CURSOR_PATH = "/V1.0/TimeEntries/query/next";
+function entryCursorPath(baseUrl, cursor) {
+  const path = cursorToPath(baseUrl, cursor);
+  if (path.split("?")[0] !== ENTRY_CURSOR_PATH) {
+    throw new ResponseRejectedError(`Refused the pagination cursor: not a TimeEntries continuation (${ENTRY_CURSOR_PATH})`);
+  }
+  return path;
+}
+async function queryTimeEntries(_resource, filter, limit, operation, http, cursor) {
+  const res = await http.request({
+    method: "POST",
+    idempotent: true,
+    path: cursor === void 0 ? "/V1.0/TimeEntries/query" : entryCursorPath(http.baseUrl, cursor),
+    body: { MaxRecords: limit, filter },
+    operation
+  });
+  const { items, pageDetails } = unwrapItems(res);
+  return { items, hasMore: pageDetails.nextPageUrl != null, nextCursor: pageDetails.nextPageUrl ?? null };
+}
+function pagingOpts(opts, OP7) {
+  if (opts?.countOnly !== void 0 && typeof opts.countOnly !== "boolean") {
+    throw new AutotaskConfigError(`${OP7}: countOnly must be a boolean`, { operation: OP7 });
+  }
+  const countOnly = opts?.countOnly === true;
+  const cursor = opts?.cursor;
+  if (cursor !== void 0 && (typeof cursor !== "string" || cursor.trim() === "")) {
+    throw new AutotaskConfigError(`${OP7}: cursor must be the non-empty nextCursor of a previous call`, { operation: OP7 });
+  }
+  if (cursor !== void 0 && cursor.length > CURSOR_MAX) {
+    throw new ResponseRejectedError(`${OP7}: refused the pagination cursor: ${cursor.length} chars is over the ${CURSOR_MAX}-char cap (a vendor nextPageUrl is far shorter)`);
+  }
+  if (cursor !== void 0 && countOnly) {
+    throw new AutotaskConfigError(`${OP7}: cursor does not apply with countOnly (countOnly reads every page itself)`, { operation: OP7 });
+  }
+  const budget = opts?.maxVendorCalls ?? COUNT_BUDGET_DEFAULT;
+  if (!Number.isInteger(budget) || budget < 1 || budget > COUNT_BUDGET_MAX) {
+    throw new AutotaskConfigError(`${OP7}: maxVendorCalls must be an integer 1-${COUNT_BUDGET_MAX} (got ${String(opts?.maxVendorCalls)})`, { operation: OP7 });
+  }
+  return { ...cursor === void 0 ? {} : { cursor }, countOnly, budget };
+}
+function budgetExceeded(OP7, details, midWalk) {
+  const { estimate, budget, total } = details;
+  const raise = midWalk ? budget < COUNT_BUDGET_MAX ? `, or pass a maxVendorCalls above ${budget} for headroom past the estimate` : "" : estimate <= COUNT_BUDGET_MAX ? ` or pass maxVendorCalls >= ${estimate}` : "";
+  return budgetExceededError(
+    OP7,
+    midWalk ? `${OP7}: countOnly stopped at the ${budget}-call budget mid-walk: the walk needed more calls than the ${estimate} estimated from the ${total}-entry count (more entries than counted, or an extra page such as an empty continuation page), so the next call, which may be the closing re-count, did not fit; no partial total is returned` : `${OP7}: countOnly needs an estimated ${estimate} vendor calls for ${total} entries (1 count + 1 per ${PAGE} entries + 1 join per 250 + 1 re-count), over the ${budget}-call budget; nothing was read past the count`,
+    details,
+    `Narrow the dateWorked window (from/to)${raise}.`
+  );
+}
+async function countPostedState(http, filter, OP7, budget, window) {
+  let estimate = 0;
+  let counted = 0;
+  const callBudget = makeCallBudget(budget, (spent) => budgetExceeded(OP7, { estimate, budget, total: counted, issued: spent }, true));
+  const spend = callBudget.spend;
+  spend();
+  counted = unwrapQueryCount(
+    await http.request({ method: "POST", idempotent: true, path: "/V1.0/TimeEntries/query/count", body: { filter }, operation: OP7 }),
+    OP7
+  );
+  estimate = 1 + Math.max(1, Math.ceil(counted / PAGE)) + Math.ceil(counted / 250) + 1;
+  if (estimate > budget) throw budgetExceeded(OP7, { estimate, budget, total: counted, issued: callBudget.spent() }, false);
+  const states = /* @__PURE__ */ new Map();
+  let cursor = null;
+  do {
+    spend();
+    const res = await http.request({
+      method: "POST",
+      idempotent: true,
+      path: cursor === null ? "/V1.0/TimeEntries/query" : entryCursorPath(http.baseUrl, cursor),
+      body: { MaxRecords: PAGE, IncludeFields: ["id"], filter },
+      operation: OP7
+    });
+    const page = unwrapItems(res);
+    const joined = await postedStateOf(http, page.items, OP7, spend);
+    if (joined.incomplete) {
+      throw new AutotaskError(`${OP7}: countOnly refused: a billing-item join page was truncated (more than 500 billing items for 250 entries), so the posted split cannot be confirmed`, {
+        code: "RESOLUTION_TRUNCATED",
+        category: "resolution",
+        operation: OP7,
+        details: { issued: callBudget.spent(), budget },
+        suggestedAction: "Narrow the dateWorked window, or page it with cursor (rows mode reports unconfirmed entries via truncated)."
+      });
+    }
+    for (const [id, state] of joined.states) states.set(id, state);
+    cursor = page.items.length === 0 ? null : page.pageDetails.nextPageUrl ?? null;
+  } while (cursor !== null);
+  spend();
+  const recounted = unwrapQueryCount(
+    await http.request({ method: "POST", idempotent: true, path: "/V1.0/TimeEntries/query/count", body: { filter }, operation: OP7 }),
+    OP7
+  );
+  if (states.size !== counted && states.size !== recounted) {
+    throw new AutotaskError(`${OP7}: countOnly read ${states.size} distinct entries but the window counted ${counted} before the walk and ${recounted} after it (a page repeated or dropped entries, or the window changed mid-walk); no total is returned. Retry the call`, {
+      code: "INVALID_RESPONSE",
+      category: "server",
+      operation: OP7,
+      details: { reason: "count_mismatch", streamed: states.size, counted, recounted, issued: callBudget.spent(), budget },
+      suggestedAction: "Retry the call; a window that changes during the walk can fail or pass depending on timing."
+    });
+  }
+  let postedCount = 0;
+  for (const state of states.values()) if (state === "posted") postedCount += 1;
+  return { window, total: states.size, postedCount, unpostedCount: states.size - postedCount, vendorCalls: callBudget.spent(), estimate, budget };
+}
+async function dateWorkedWindow(resource, from, to, opts) {
+  const http = resource.http;
+  const OP7 = "time_entries.dateWorkedWindow";
+  const paging = pagingOpts(opts, OP7);
+  const { fromMs, toMs } = windowBounds(from, to, OP7);
+  const windowToMs = toMs + DAY_MS - 1;
+  const filter = [
+    { field: "dateWorked", op: "gte", value: iso(fromMs) },
+    { field: "dateWorked", op: "lte", value: iso(windowToMs) }
+  ];
+  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 window = { from: iso(fromMs), to: iso(windowToMs) };
+  if (paging.countOnly) return countPostedState(http, filter, OP7, paging.budget, window);
+  const { items, hasMore, nextCursor } = await queryTimeEntries(resource, filter, clampWindowLimit(opts?.limit, OP7), OP7, http, paging.cursor);
+  const { states, incomplete } = await postedStateOf(http, items, OP7);
+  let postedCount = 0;
+  let unpostedCount = 0;
+  for (const state of states.values()) {
+    if (state === "posted") postedCount += 1;
+    else unpostedCount += 1;
+  }
+  return {
+    items: items.filter((e) => states.has(e.id) && (opts?.state === void 0 || states.get(e.id) === opts.state)),
+    postedCount,
+    unpostedCount,
+    window,
+    nextCursor,
+    unconfirmed: items.filter((e) => !states.has(e.id)).length,
+    // A live next-page cursor past the bounded read: the counts above cover
+    // the returned rows ONLY when this is true (issue #66 AC1 — the 500-row cap case is the general case).
+    truncated: hasMore || incomplete
+  };
+}
+function clampWindowLimit(limit, OP7) {
+  const n = limit === void 0 ? PAGE : Math.trunc(limit);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new AutotaskConfigError(`limit must be an integer >= 1 (got ${String(limit)})`, { operation: OP7 });
+  }
+  return Math.min(n, PAGE);
+}
+
+// src/resources/time_entries.ts
+var TimeEntriesResource = class extends BaseResource {
+  constructor(http, pageSize) {
+    super(http, {
+      key: "time_entries",
+      resourcePath: "/V1.0/TimeEntries",
+      deletable: true,
+      udfCapable: true,
+      collectionUpdate: true
+      // D1: the spec's item path is GET-only — confirmed updates PUT the collection (id in the body)
+    }, pageSize);
+  }
+  /** Query TimeEntry records with the G3 filter surface (server-side JSON filter). */
+  query(params) {
+    return this.queryItems(params);
+  }
+  /** Get every TimeEntry 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). `fresh: true` bypasses the read-cache lookup and refreshes the entry (issue #250). */
+  async get(id, opts = {}) {
+    return this.getGlobal(id, opts?.fresh === true);
+  }
+  /** 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);
+  }
+  /** Delete a record (OperationResultModel → { id}). `dryRun: true` returns the pinned
+   * envelope and never issues the delete. */
+  async delete(id, opts = {}) {
+    if (opts.dryRun === true) return this.runDeleteDryRun(id, opts);
+    await this.guardStaleBeforeMutation(id, opts, "time_entries.delete");
+    return this.deleteGlobal(id, opts);
+  }
+  /** Resolve a TimeEntry from a numeric id (or, where the vendor indexes a primary text field,
+   * from a numeric id — this resource has no primary text field). A numeric id miss throws NOT_FOUND;
+   * a bare value rejects with a config error (ids only);
+   * non-match returns null; ambiguity throws RESOLUTION_AMBIGUOUS (candidate ids) and a
+   * cap-tripped bounded client scan throws RESOLUTION_TRUNCATED (never a silent null).
+   * The compact shape is the structural alias of the full record; `expand: true` is the
+   * type-level escape hatch. */
+  async resolve(identifier, opts = {}) {
+    void opts;
+    return this.resolveBase(identifier);
+  }
+  dateWorkedWindow(from, to, opts) {
+    return dateWorkedWindow(this, from, to, opts);
+  }
+  /** Node-parity special op (hand-written in src/resources/special/time_entries/move.ts). */
+  moveToTicket(sourceId, toTicketId, opts = {}) {
+    return moveToTicket2(this, sourceId, toTicketId, opts);
+  }
+};
+
 // src/resources/time_entry_attachments.ts
 var TimeEntryAttachmentsResource = class extends BaseResource {
   constructor(http, pageSize) {
@@ -8846,7 +9273,8 @@ var TimeEntryAttachmentsResource = class extends BaseResource {
 };
 
 // src/resources/special/time_off_requests.ts
-async function approve(_resource, id, opts = {}, http) {
+async function approve(_resource, id, opts = {}) {
+  const http = _resource.http;
   const numericId = parseIdentifier(id, "id");
   if (opts.dryRun === true) {
     return buildDryRunResult({
@@ -8867,7 +9295,8 @@ async function approve(_resource, id, opts = {}, http) {
   });
   return unwrapOperation(res);
 }
-async function reject(_resource, id, reason, opts = {}, http) {
+async function reject(_resource, id, reason, opts = {}) {
+  const http = _resource.http;
   const numericId = parseIdentifier(id, "id");
   const text = reason.trim();
   if (text === "") {
@@ -8934,11 +9363,11 @@ 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 approve(this, id, opts);
   }
   /** Node-parity special op (hand-written in src/resources/special/time_off_requests.ts). */
   reject(id, reason, opts = {}) {
-    return reject(this, id, reason, opts, this.http);
+    return reject(this, id, reason, opts);
   }
 };
 
@@ -9005,6 +9434,7 @@ var ZoneInformationResource = class {
 export {
   AppointmentsResource,
   AuthenticateResource,
+  BillingCodesResource,
   BillingItemApprovalLevelsResource,
   ChangeRequestLinksResource,
   ChecklistLibrariesResource,
@@ -9084,6 +9514,7 @@ export {
   ResourceRoleQueuesResource,
   ResourceRolesResource,
   ResourceSkillsResource,
+  ResourcesResource,
   ResourceTimeOffAdditionalResource,
   ResourceTimeOffApproversResource,
   ResourceTimeOffBalancesResource,
@@ -9124,6 +9555,7 @@ export {
   TicketSecondaryResourcesResource,
   TicketsResource,
   TicketWebhooksResource,
+  TimeEntriesResource,
   TimeEntryAttachmentsResource,
   TimeOffRequestsResource,
   VersionInformationResource,