netsuite-sdk 0.1.2 → 0.1.31

package/dist/index.mjs

@@ -1,819 +1,2067 @@
-import axios from 'axios';
-import http from 'http';
-import https from 'https';
-import OAuth from 'oauth-1.0a';
-import { createHmac } from 'crypto';
+import { randomBytes, createHmac } from 'crypto';
 
-// src/transport/http-transport.ts
-function createOAuthSigner(config) {
-  const oauth = new OAuth({
-    consumer: { key: config.consumerKey, secret: config.consumerSecret },
-    signature_method: "HMAC-SHA256",
-    hash_function: (baseString, key) => createHmac("sha256", key).update(baseString).digest("base64"),
-    realm: config.realm
-  });
-  const token = { key: config.tokenKey, secret: config.tokenSecret };
-  return (url, method) => {
-    const requestData = { url, method };
-    const authorization = oauth.authorize(requestData, token);
-    return oauth.toHeader(authorization);
-  };
-}
-
-// src/types/errors.ts
-var NetSuiteError = class _NetSuiteError extends Error {
-  status;
-  code;
-  details;
-  requestUrl;
-  requestMethod;
-  constructor(message, status, code, details, requestUrl, requestMethod) {
-    super(message);
-    this.name = "NetSuiteError";
-    this.status = status;
-    this.code = code;
-    this.details = details;
-    this.requestUrl = requestUrl;
-    this.requestMethod = requestMethod;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _NetSuiteError);
-    }
-  }
-  /** Whether this is a retryable error (5xx, timeout, network) */
-  get isRetryable() {
-    return this.status >= 500 || this.code === "TIMEOUT" || this.code === "NETWORK_ERROR";
-  }
-  /** Whether this is an auth error (401, 403) */
-  get isAuthError() {
-    return this.status === 401 || this.status === 403;
-  }
-  static isNetSuiteError(error) {
-    return error instanceof _NetSuiteError;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
-// src/transport/retry.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 3,
-  initialDelay: 1e3,
-  maxDelay: 3e4,
-  backoffFactor: 2,
-  shouldRetry: (error) => {
-    if (error instanceof NetSuiteError) {
-      return error.isRetryable;
+// src/transport/oauth.js
+var require_oauth = __commonJS({
+  "src/transport/oauth.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.createOAuthSigner = createOAuthSigner;
+    var oauth_1_0a_1 = __require("oauth-1.0a");
+    var node_crypto_1 = __require("crypto");
+    function createOAuthSigner(config) {
+      var oauth = new oauth_1_0a_1.default({
+        consumer: { key: config.consumerKey, secret: config.consumerSecret },
+        signature_method: "HMAC-SHA256",
+        hash_function: function(baseString, key) {
+          return (0, node_crypto_1.createHmac)("sha256", key).update(baseString).digest("base64");
+        },
+        realm: config.realm
+      });
+      var token = { key: config.tokenKey, secret: config.tokenSecret };
+      return function(url, method) {
+        var requestData = { url, method };
+        var authorization = oauth.authorize(requestData, token);
+        return oauth.toHeader(authorization);
+      };
     }
-    return true;
   }
-};
-async function withRetry(fn, config = {}) {
-  const opts = { ...DEFAULT_RETRY_CONFIG, ...config };
-  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      const isLastAttempt = attempt === opts.maxRetries;
-      if (isLastAttempt || !opts.shouldRetry(error, attempt)) {
-        throw error;
-      }
-      opts.onRetry?.(error, attempt + 1);
-      const delay = Math.min(
-        opts.initialDelay * Math.pow(opts.backoffFactor, attempt),
-        opts.maxDelay
-      );
-      const jitter = delay * 0.25 * (Math.random() * 2 - 1);
-      await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+});
+
+// src/types/errors.js
+var require_errors = __commonJS({
+  "src/types/errors.js"(exports$1) {
+    var __extends = exports$1 && exports$1.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.NetSuiteError = void 0;
+    var NetSuiteError2 = (
+      /** @class */
+      (function(_super) {
+        __extends(NetSuiteError3, _super);
+        function NetSuiteError3(message, status, code, details, requestUrl, requestMethod) {
+          var _this = _super.call(this, message) || this;
+          _this.name = "NetSuiteError";
+          _this.status = status;
+          _this.code = code;
+          _this.details = details;
+          _this.requestUrl = requestUrl;
+          _this.requestMethod = requestMethod;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(_this, NetSuiteError3);
+          }
+          return _this;
+        }
+        Object.defineProperty(NetSuiteError3.prototype, "isRetryable", {
+          /** Whether this is a retryable error (5xx, timeout, network) */
+          get: function() {
+            return this.status >= 500 || this.code === "TIMEOUT" || this.code === "NETWORK_ERROR";
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(NetSuiteError3.prototype, "isAuthError", {
+          /** Whether this is an auth error (401, 403) */
+          get: function() {
+            return this.status === 401 || this.status === 403;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        NetSuiteError3.isNetSuiteError = function(error) {
+          return error instanceof NetSuiteError3;
+        };
+        return NetSuiteError3;
+      })(Error)
+    );
+    exports$1.NetSuiteError = NetSuiteError2;
+  }
+});
+
+// src/transport/retry.js
+var require_retry = __commonJS({
+  "src/transport/retry.js"(exports$1) {
+    var __assign = exports$1 && exports$1.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __awaiter = exports$1 && exports$1.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports$1 && exports$1.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.withRetry = withRetry;
+    var errors_js_1 = require_errors();
+    var DEFAULT_RETRY_CONFIG = {
+      maxRetries: 3,
+      initialDelay: 1e3,
+      maxDelay: 3e4,
+      backoffFactor: 2,
+      shouldRetry: function(error) {
+        if (error instanceof errors_js_1.NetSuiteError) {
+          return error.isRetryable;
+        }
+        return true;
+      }
+    };
+    function withRetry(fn_1) {
+      return __awaiter(this, arguments, void 0, function(fn, config) {
+        var opts, _loop_1, attempt, state_1;
+        var _a;
+        if (config === void 0) {
+          config = {};
+        }
+        return __generator(this, function(_b) {
+          switch (_b.label) {
+            case 0:
+              opts = __assign(__assign({}, DEFAULT_RETRY_CONFIG), config);
+              _loop_1 = function(attempt2) {
+                var _c, error_1, isLastAttempt, delay_1, jitter_1;
+                return __generator(this, function(_d) {
+                  switch (_d.label) {
+                    case 0:
+                      _d.trys.push([0, 2, , 4]);
+                      _c = {};
+                      return [4, fn()];
+                    case 1:
+                      return [2, (_c.value = _d.sent(), _c)];
+                    case 2:
+                      error_1 = _d.sent();
+                      isLastAttempt = attempt2 === opts.maxRetries;
+                      if (isLastAttempt || !opts.shouldRetry(error_1, attempt2)) {
+                        throw error_1;
+                      }
+                      (_a = opts.onRetry) === null || _a === void 0 ? void 0 : _a.call(opts, error_1, attempt2 + 1);
+                      delay_1 = Math.min(opts.initialDelay * Math.pow(opts.backoffFactor, attempt2), opts.maxDelay);
+                      jitter_1 = delay_1 * 0.25 * (Math.random() * 2 - 1);
+                      return [4, new Promise(function(resolve) {
+                        return setTimeout(resolve, delay_1 + jitter_1);
+                      })];
+                    case 3:
+                      _d.sent();
+                      return [3, 4];
+                    case 4:
+                      return [
+                        2
+                        /*return*/
+                      ];
+                  }
+                });
+              };
+              attempt = 0;
+              _b.label = 1;
+            case 1:
+              if (!(attempt <= opts.maxRetries)) return [3, 4];
+              return [5, _loop_1(attempt)];
+            case 2:
+              state_1 = _b.sent();
+              if (typeof state_1 === "object")
+                return [2, state_1.value];
+              _b.label = 3;
+            case 3:
+              attempt++;
+              return [3, 1];
+            case 4:
+              throw new Error("Retry loop exited unexpectedly");
+          }
+        });
+      });
     }
   }
-  throw new Error("Retry loop exited unexpectedly");
-}
+});
 
-// src/transport/middleware-chain.ts
-function executeMiddlewareChain(middlewares, context, finalHandler) {
-  let index = 0;
-  function next() {
-    if (index >= middlewares.length) {
-      return finalHandler();
+// src/transport/middleware-chain.js
+var require_middleware_chain = __commonJS({
+  "src/transport/middleware-chain.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.executeMiddlewareChain = executeMiddlewareChain;
+    function executeMiddlewareChain(middlewares, context, finalHandler) {
+      var index = 0;
+      function next() {
+        if (index >= middlewares.length) {
+          return finalHandler();
+        }
+        var middleware = middlewares[index++];
+        return middleware(context, next);
+      }
+      return next();
     }
-    const middleware = middlewares[index++];
-    return middleware(context, next);
   }
-  return next();
-}
+});
 
-// src/types/http.ts
-function extractHeaders(response) {
-  const headers = {};
-  if (response.headers) {
-    for (const [key, value] of Object.entries(response.headers)) {
-      if (typeof value === "string") {
-        headers[key] = value;
+// src/types/http.js
+var require_http = __commonJS({
+  "src/types/http.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.extractHeaders = extractHeaders;
+    function extractHeaders(response) {
+      var headers = {};
+      if (response.headers) {
+        for (var _i = 0, _a = Object.entries(response.headers); _i < _a.length; _i++) {
+          var _b = _a[_i], key = _b[0], value = _b[1];
+          if (typeof value === "string") {
+            headers[key] = value;
+          }
+        }
       }
+      return headers;
     }
   }
-  return headers;
-}
+});
 
-// src/transport/http-transport.ts
-var HttpTransport = class {
-  sign;
-  axiosInstance;
-  middlewares = [];
-  config;
-  constructor(config) {
-    this.config = {
-      timeout: config.timeout ?? 3e4,
-      maxRetries: config.maxRetries ?? 3,
-      retryDelay: config.retryDelay ?? 1e3,
-      defaultHeaders: config.defaultHeaders ?? {},
-      logger: config.logger
+// src/transport/http-transport.js
+var require_http_transport = __commonJS({
+  "src/transport/http-transport.js"(exports$1) {
+    var __assign = exports$1 && exports$1.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
     };
-    this.sign = createOAuthSigner(config.auth);
-    this.axiosInstance = axios.create({
-      timeout: this.config.timeout,
-      headers: {
-        "Content-Type": "application/json",
-        "Accept-Encoding": "gzip, deflate"
-      },
-      httpAgent: new http.Agent({ keepAlive: true }),
-      httpsAgent: new https.Agent({ keepAlive: true }),
-      maxRedirects: 5,
-      // Let us handle all status codes in our error handling
-      validateStatus: () => true
-    });
-  }
-  /** Add a middleware to the chain. Returns `this` for chaining. */
-  use(middleware) {
-    this.middlewares.push(middleware);
-    return this;
-  }
-  /** Execute an HTTP request with OAuth signing, retry, and middleware. */
-  async request(url, options = {}) {
-    const method = options.method ?? "GET";
-    const timeout = options.timeout ?? this.config.timeout;
-    const maxRetries = options.maxRetries ?? this.config.maxRetries;
-    return withRetry(
-      async () => {
-        const authHeaders = this.sign(url, method);
-        const headers = {
-          "Content-Type": "application/json",
-          ...this.config.defaultHeaders,
-          ...authHeaders,
-          ...options.headers
-        };
-        const context = {
-          url,
-          method,
-          headers,
-          body: options.body,
-          metadata: {}
-        };
-        const response = await executeMiddlewareChain(
-          this.middlewares,
-          context,
-          () => this.executeRequest(context, timeout)
-        );
-        return {
-          data: response.body,
-          status: response.status,
-          headers: response.headers,
-          duration: response.duration
+    var __awaiter = exports$1 && exports$1.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports$1 && exports$1.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
         };
-      },
-      {
-        maxRetries,
-        initialDelay: this.config.retryDelay,
-        shouldRetry: (error) => {
-          if (error instanceof NetSuiteError) {
-            return error.isRetryable;
-          }
-          return true;
-        },
-        onRetry: (error, attempt) => {
-          this.config.logger?.warn(`Retry attempt ${attempt}/${maxRetries}`, {
-            url,
-            method,
-            error
-          });
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
         }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
       }
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.HttpTransport = void 0;
+    var axios_1 = __require("axios");
+    var node_http_1 = __require("http");
+    var node_https_1 = __require("https");
+    var oauth_js_1 = require_oauth();
+    var retry_js_1 = require_retry();
+    var middleware_chain_js_1 = require_middleware_chain();
+    var errors_js_1 = require_errors();
+    var http_js_1 = require_http();
+    var HttpTransport = (
+      /** @class */
+      (function() {
+        function HttpTransport2(config) {
+          var _a, _b, _c, _d;
+          this.middlewares = [];
+          this.config = {
+            timeout: (_a = config.timeout) !== null && _a !== void 0 ? _a : 3e4,
+            maxRetries: (_b = config.maxRetries) !== null && _b !== void 0 ? _b : 3,
+            retryDelay: (_c = config.retryDelay) !== null && _c !== void 0 ? _c : 1e3,
+            defaultHeaders: (_d = config.defaultHeaders) !== null && _d !== void 0 ? _d : {},
+            logger: config.logger
+          };
+          this.sign = (0, oauth_js_1.createOAuthSigner)(config.auth);
+          this.axiosInstance = axios_1.default.create({
+            timeout: this.config.timeout,
+            headers: {
+              "Content-Type": "application/json",
+              "Accept-Encoding": "gzip, deflate"
+            },
+            httpAgent: new node_http_1.default.Agent({ keepAlive: true }),
+            httpsAgent: new node_https_1.default.Agent({ keepAlive: true }),
+            maxRedirects: 5,
+            // Let us handle all status codes in our error handling
+            validateStatus: function() {
+              return true;
+            }
+          });
+        }
+        HttpTransport2.prototype.use = function(middleware) {
+          this.middlewares.push(middleware);
+          return this;
+        };
+        HttpTransport2.prototype.request = function(url_1) {
+          return __awaiter(this, arguments, void 0, function(url, options) {
+            var method, timeout, maxRetries;
+            var _this = this;
+            var _a, _b, _c;
+            if (options === void 0) {
+              options = {};
+            }
+            return __generator(this, function(_d) {
+              method = (_a = options.method) !== null && _a !== void 0 ? _a : "GET";
+              timeout = (_b = options.timeout) !== null && _b !== void 0 ? _b : this.config.timeout;
+              maxRetries = (_c = options.maxRetries) !== null && _c !== void 0 ? _c : this.config.maxRetries;
+              return [2, (0, retry_js_1.withRetry)(function() {
+                return __awaiter(_this, void 0, void 0, function() {
+                  var authHeaders, headers, context, response;
+                  var _this2 = this;
+                  return __generator(this, function(_a2) {
+                    switch (_a2.label) {
+                      case 0:
+                        authHeaders = this.sign(url, method);
+                        headers = __assign(__assign(__assign({ "Content-Type": "application/json" }, this.config.defaultHeaders), authHeaders), options.headers);
+                        context = {
+                          url,
+                          method,
+                          headers,
+                          body: options.body,
+                          metadata: {}
+                        };
+                        return [4, (0, middleware_chain_js_1.executeMiddlewareChain)(this.middlewares, context, function() {
+                          return _this2.executeRequest(context, timeout);
+                        })];
+                      case 1:
+                        response = _a2.sent();
+                        return [2, {
+                          data: response.body,
+                          status: response.status,
+                          headers: response.headers,
+                          duration: response.duration
+                        }];
+                    }
+                  });
+                });
+              }, {
+                maxRetries,
+                initialDelay: this.config.retryDelay,
+                shouldRetry: function(error) {
+                  if (error instanceof errors_js_1.NetSuiteError) {
+                    return error.isRetryable;
+                  }
+                  return true;
+                },
+                onRetry: function(error, attempt) {
+                  var _a2;
+                  (_a2 = _this.config.logger) === null || _a2 === void 0 ? void 0 : _a2.warn("Retry attempt ".concat(attempt, "/").concat(maxRetries), {
+                    url,
+                    method,
+                    error
+                  });
+                }
+              })];
+            });
+          });
+        };
+        HttpTransport2.prototype.executeRequest = function(context, timeout) {
+          return __awaiter(this, void 0, void 0, function() {
+            var startTime, response, duration, errorBody, message, code, error_1, duration, axiosError;
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            return __generator(this, function(_j) {
+              switch (_j.label) {
+                case 0:
+                  startTime = performance.now();
+                  _j.label = 1;
+                case 1:
+                  _j.trys.push([1, 3, , 4]);
+                  (_a = this.config.logger) === null || _a === void 0 ? void 0 : _a.debug("".concat(context.method, " ").concat(context.url), {
+                    headers: Object.keys(context.headers)
+                  });
+                  return [4, this.axiosInstance.request({
+                    url: context.url,
+                    method: context.method,
+                    headers: context.headers,
+                    data: context.body && ["POST", "PUT", "PATCH"].includes(context.method) ? context.body : void 0,
+                    timeout
+                  })];
+                case 2:
+                  response = _j.sent();
+                  duration = Math.round(performance.now() - startTime);
+                  (_b = this.config.logger) === null || _b === void 0 ? void 0 : _b.info("".concat(context.method, " ").concat(context.url, " \u2192 ").concat(response.status), {
+                    duration
+                  });
+                  if (response.status >= 400) {
+                    errorBody = (_c = response.data) !== null && _c !== void 0 ? _c : {};
+                    message = (_f = (_e = (_d = errorBody.detail) !== null && _d !== void 0 ? _d : errorBody.title) !== null && _e !== void 0 ? _e : errorBody.message) !== null && _f !== void 0 ? _f : "HTTP ".concat(response.status);
+                    code = (_h = (_g = errorBody["o:errorCode"]) !== null && _g !== void 0 ? _g : errorBody.code) !== null && _h !== void 0 ? _h : "HTTP_".concat(response.status);
+                    throw new errors_js_1.NetSuiteError(message, response.status, code, errorBody, context.url, context.method);
+                  }
+                  return [2, {
+                    status: response.status,
+                    headers: (0, http_js_1.extractHeaders)(response),
+                    body: response.status === 204 ? void 0 : response.data,
+                    duration
+                  }];
+                case 3:
+                  error_1 = _j.sent();
+                  if (error_1 instanceof errors_js_1.NetSuiteError) {
+                    throw error_1;
+                  }
+                  duration = Math.round(performance.now() - startTime);
+                  axiosError = error_1;
+                  if (axiosError.code === "ECONNABORTED" || axiosError.code === "ERR_CANCELED") {
+                    throw new errors_js_1.NetSuiteError("Request timed out after ".concat(timeout, "ms"), 504, "TIMEOUT", void 0, context.url, context.method);
+                  }
+                  throw new errors_js_1.NetSuiteError(axiosError.message || "Network error", 0, "NETWORK_ERROR", void 0, context.url, context.method);
+                case 4:
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        return HttpTransport2;
+      })()
     );
+    exports$1.HttpTransport = HttpTransport;
   }
-  async executeRequest(context, timeout) {
-    const startTime = performance.now();
-    try {
-      this.config.logger?.debug(`${context.method} ${context.url}`, {
-        headers: Object.keys(context.headers)
-      });
-      const response = await this.axiosInstance.request({
-        url: context.url,
-        method: context.method,
-        headers: context.headers,
-        data: context.body && ["POST", "PUT", "PATCH"].includes(context.method) ? context.body : void 0,
-        timeout
-      });
-      const duration = Math.round(performance.now() - startTime);
-      this.config.logger?.info(`${context.method} ${context.url} \u2192 ${response.status}`, {
-        duration
+});
+
+// src/suiteql/suiteql-client.js
+var require_suiteql_client = __commonJS({
+  "src/suiteql/suiteql-client.js"(exports$1) {
+    var __assign = exports$1 && exports$1.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __awaiter = exports$1 && exports$1.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
-      if (response.status >= 400) {
-        const errorBody = response.data ?? {};
-        const message = errorBody.detail ?? errorBody.title ?? errorBody.message ?? `HTTP ${response.status}`;
-        const code = errorBody["o:errorCode"] ?? errorBody.code ?? `HTTP_${response.status}`;
-        throw new NetSuiteError(
-          message,
-          response.status,
-          code,
-          errorBody,
-          context.url,
-          context.method
-        );
+    };
+    var __generator = exports$1 && exports$1.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
       }
-      return {
-        status: response.status,
-        headers: extractHeaders(response),
-        body: response.status === 204 ? void 0 : response.data,
-        duration
-      };
-    } catch (error) {
-      if (error instanceof NetSuiteError) {
-        throw error;
-      }
-      Math.round(performance.now() - startTime);
-      const axiosError = error;
-      if (axiosError.code === "ECONNABORTED" || axiosError.code === "ERR_CANCELED") {
-        throw new NetSuiteError(
-          `Request timed out after ${timeout}ms`,
-          504,
-          "TIMEOUT",
-          void 0,
-          context.url,
-          context.method
-        );
-      }
-      throw new NetSuiteError(
-        axiosError.message || "Network error",
-        0,
-        "NETWORK_ERROR",
-        void 0,
-        context.url,
-        context.method
-      );
-    }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    var __await = exports$1 && exports$1.__await || function(v) {
+      return this instanceof __await ? (this.v = v, this) : new __await(v);
+    };
+    var __asyncGenerator = exports$1 && exports$1.__asyncGenerator || function(thisArg, _arguments, generator) {
+      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+      var g = generator.apply(thisArg, _arguments || []), i, q = [];
+      return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+        return this;
+      }, i;
+      function awaitReturn(f) {
+        return function(v) {
+          return Promise.resolve(v).then(f, reject);
+        };
+      }
+      function verb(n, f) {
+        if (g[n]) {
+          i[n] = function(v) {
+            return new Promise(function(a, b) {
+              q.push([n, v, a, b]) > 1 || resume(n, v);
+            });
+          };
+          if (f) i[n] = f(i[n]);
+        }
+      }
+      function resume(n, v) {
+        try {
+          step(g[n](v));
+        } catch (e) {
+          settle(q[0][3], e);
+        }
+      }
+      function step(r) {
+        r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+      }
+      function fulfill(value) {
+        resume("next", value);
+      }
+      function reject(value) {
+        resume("throw", value);
+      }
+      function settle(f, v) {
+        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+      }
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.SuiteQLClient = void 0;
+    var SuiteQLClient = (
+      /** @class */
+      (function() {
+        function SuiteQLClient2(transport, accountId) {
+          this.transport = transport;
+          var normalizedId = accountId.toLowerCase().replace(/_/g, "-");
+          this.baseUrl = "https://".concat(normalizedId, ".suitetalk.api.netsuite.com/services/rest/query/v1/suiteql");
+        }
+        SuiteQLClient2.prototype.query = function(sql_1) {
+          return __awaiter(this, arguments, void 0, function(sql, options) {
+            var _a, pageSize, _b, startOffset, _c, maxRows, timeout, allItems, currentOffset, totalResults, pagesFetched, startTime, effectiveLimit, url, response, page, hasMore;
+            if (options === void 0) {
+              options = {};
+            }
+            return __generator(this, function(_d) {
+              switch (_d.label) {
+                case 0:
+                  _a = options.pageSize, pageSize = _a === void 0 ? 1e3 : _a, _b = options.offset, startOffset = _b === void 0 ? 0 : _b, _c = options.maxRows, maxRows = _c === void 0 ? Infinity : _c, timeout = options.timeout;
+                  allItems = [];
+                  currentOffset = startOffset;
+                  totalResults = 0;
+                  pagesFetched = 0;
+                  startTime = performance.now();
+                  _d.label = 1;
+                case 1:
+                  effectiveLimit = Math.min(pageSize, maxRows - allItems.length);
+                  if (effectiveLimit <= 0)
+                    return [3, 3];
+                  url = "".concat(this.baseUrl, "?limit=").concat(effectiveLimit, "&offset=").concat(currentOffset);
+                  return [4, this.transport.request(url, {
+                    method: "POST",
+                    body: { q: sql },
+                    headers: { Prefer: "transient" },
+                    timeout
+                  })];
+                case 2:
+                  response = _d.sent();
+                  page = response.data;
+                  totalResults = page.totalResults;
+                  pagesFetched++;
+                  allItems.push.apply(allItems, page.items);
+                  hasMore = page.hasMore || currentOffset + page.items.length < totalResults;
+                  if (!hasMore || allItems.length >= maxRows || page.items.length === 0)
+                    return [3, 3];
+                  currentOffset += page.items.length;
+                  return [3, 1];
+                case 3:
+                  return [2, {
+                    items: allItems,
+                    totalResults,
+                    pagesFetched,
+                    hasMore: allItems.length < totalResults,
+                    duration: Math.round(performance.now() - startTime)
+                  }];
+              }
+            });
+          });
+        };
+        SuiteQLClient2.prototype.queryOne = function(sql, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            var result;
+            var _a;
+            return __generator(this, function(_b) {
+              switch (_b.label) {
+                case 0:
+                  return [4, this.query(sql, __assign(__assign({}, options), { maxRows: 1 }))];
+                case 1:
+                  result = _b.sent();
+                  return [2, (_a = result.items[0]) !== null && _a !== void 0 ? _a : null];
+              }
+            });
+          });
+        };
+        SuiteQLClient2.prototype.queryPages = function(sql_1) {
+          return __asyncGenerator(this, arguments, function queryPages_1(sql, options) {
+            var _a, pageSize, _b, startOffset, _c, maxRows, timeout, currentOffset, totalYielded, effectiveLimit, url, response, page, hasMore;
+            if (options === void 0) {
+              options = {};
+            }
+            return __generator(this, function(_d) {
+              switch (_d.label) {
+                case 0:
+                  _a = options.pageSize, pageSize = _a === void 0 ? 1e3 : _a, _b = options.offset, startOffset = _b === void 0 ? 0 : _b, _c = options.maxRows, maxRows = _c === void 0 ? Infinity : _c, timeout = options.timeout;
+                  currentOffset = startOffset;
+                  totalYielded = 0;
+                  _d.label = 1;
+                case 1:
+                  effectiveLimit = Math.min(pageSize, maxRows - totalYielded);
+                  if (!(effectiveLimit <= 0)) return [3, 3];
+                  return [4, __await(void 0)];
+                case 2:
+                  return [2, _d.sent()];
+                case 3:
+                  url = "".concat(this.baseUrl, "?limit=").concat(effectiveLimit, "&offset=").concat(currentOffset);
+                  return [4, __await(this.transport.request(url, {
+                    method: "POST",
+                    body: { q: sql },
+                    headers: { Prefer: "transient" },
+                    timeout
+                  }))];
+                case 4:
+                  response = _d.sent();
+                  page = response.data;
+                  if (!(page.items.length === 0)) return [3, 6];
+                  return [4, __await(void 0)];
+                case 5:
+                  return [2, _d.sent()];
+                case 6:
+                  return [4, __await(page.items)];
+                case 7:
+                  return [4, _d.sent()];
+                case 8:
+                  _d.sent();
+                  totalYielded += page.items.length;
+                  hasMore = page.hasMore || currentOffset + page.items.length < page.totalResults;
+                  if (!(!hasMore || totalYielded >= maxRows)) return [3, 10];
+                  return [4, __await(void 0)];
+                case 9:
+                  return [2, _d.sent()];
+                case 10:
+                  currentOffset += page.items.length;
+                  return [3, 1];
+                case 11:
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        return SuiteQLClient2;
+      })()
+    );
+    exports$1.SuiteQLClient = SuiteQLClient;
   }
-};
+});
 
-// src/suiteql/suiteql-client.ts
-var SuiteQLClient = class {
-  transport;
-  baseUrl;
-  constructor(transport, accountId) {
-    this.transport = transport;
-    const normalizedId = accountId.toLowerCase().replace(/_/g, "-");
-    this.baseUrl = `https://${normalizedId}.suitetalk.api.netsuite.com/services/rest/query/v1/suiteql`;
-  }
-  /**
-   * Execute a SuiteQL query and return all matching rows.
-   * Automatically paginates across multiple pages.
-   *
-   * @example
-   * ```ts
-   * const result = await client.suiteql.query<Customer>(
-   *   'SELECT id, companyname, email FROM customer WHERE isinactive = \'F\'',
-   *   { pageSize: 500 }
-   * );
-   * console.log(result.items); // all rows
-   * console.log(result.totalResults); // total count from NetSuite
-   * ```
-   */
-  async query(sql, options = {}) {
-    const {
-      pageSize = 1e3,
-      offset: startOffset = 0,
-      maxRows = Infinity,
-      timeout
-    } = options;
-    const allItems = [];
-    let currentOffset = startOffset;
-    let totalResults = 0;
-    let pagesFetched = 0;
-    const startTime = performance.now();
-    while (true) {
-      const effectiveLimit = Math.min(pageSize, maxRows - allItems.length);
-      if (effectiveLimit <= 0) break;
-      const url = `${this.baseUrl}?limit=${effectiveLimit}&offset=${currentOffset}`;
-      const response = await this.transport.request(url, {
-        method: "POST",
-        body: { q: sql },
-        headers: { Prefer: "transient" },
-        timeout
+// src/records/record-client.js
+var require_record_client = __commonJS({
+  "src/records/record-client.js"(exports$1) {
+    var __awaiter = exports$1 && exports$1.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
-      const page = response.data;
-      totalResults = page.totalResults;
-      pagesFetched++;
-      allItems.push(...page.items);
-      const hasMore = page.hasMore || currentOffset + page.items.length < totalResults;
-      if (!hasMore || allItems.length >= maxRows || page.items.length === 0) break;
-      currentOffset += page.items.length;
-    }
-    return {
-      items: allItems,
-      totalResults,
-      pagesFetched,
-      hasMore: allItems.length < totalResults,
-      duration: Math.round(performance.now() - startTime)
     };
+    var __generator = exports$1 && exports$1.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.RecordClient = void 0;
+    var RecordClient = (
+      /** @class */
+      (function() {
+        function RecordClient2(transport, accountId) {
+          this.transport = transport;
+          var normalizedId = accountId.toLowerCase().replace(/_/g, "-");
+          this.baseUrl = "https://".concat(normalizedId, ".suitetalk.api.netsuite.com/services/rest/record/v1");
+        }
+        RecordClient2.prototype.get = function(recordType, id, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            var params, qs, url;
+            var _a;
+            return __generator(this, function(_b) {
+              params = new URLSearchParams();
+              if ((_a = options === null || options === void 0 ? void 0 : options.fields) === null || _a === void 0 ? void 0 : _a.length) {
+                params.set("fields", options.fields.join(","));
+              }
+              if (options === null || options === void 0 ? void 0 : options.expandSubResources) {
+                params.set("expandSubResources", "true");
+              }
+              qs = params.toString();
+              url = "".concat(this.baseUrl, "/").concat(recordType, "/").concat(id).concat(qs ? "?".concat(qs) : "");
+              return [2, this.transport.request(url)];
+            });
+          });
+        };
+        RecordClient2.prototype.list = function(recordType, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            var params, _i, _a, _b, key, value, qs, url;
+            var _c;
+            return __generator(this, function(_d) {
+              params = new URLSearchParams();
+              if ((options === null || options === void 0 ? void 0 : options.limit) != null)
+                params.set("limit", String(options.limit));
+              if ((options === null || options === void 0 ? void 0 : options.offset) != null)
+                params.set("offset", String(options.offset));
+              if ((_c = options === null || options === void 0 ? void 0 : options.fields) === null || _c === void 0 ? void 0 : _c.length)
+                params.set("fields", options.fields.join(","));
+              if (options === null || options === void 0 ? void 0 : options.expandSubResources)
+                params.set("expandSubResources", "true");
+              if (options === null || options === void 0 ? void 0 : options.query) {
+                for (_i = 0, _a = Object.entries(options.query); _i < _a.length; _i++) {
+                  _b = _a[_i], key = _b[0], value = _b[1];
+                  params.set(key, value);
+                }
+              }
+              qs = params.toString();
+              url = "".concat(this.baseUrl, "/").concat(recordType).concat(qs ? "?".concat(qs) : "");
+              return [2, this.transport.request(url)];
+            });
+          });
+        };
+        RecordClient2.prototype.create = function(recordType, body) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request("".concat(this.baseUrl, "/").concat(recordType), {
+                method: "POST",
+                body
+              })];
+            });
+          });
+        };
+        RecordClient2.prototype.update = function(recordType, id, body) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request("".concat(this.baseUrl, "/").concat(recordType, "/").concat(id), {
+                method: "PATCH",
+                body
+              })];
+            });
+          });
+        };
+        RecordClient2.prototype.replace = function(recordType, id, body) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request("".concat(this.baseUrl, "/").concat(recordType, "/").concat(id), {
+                method: "PUT",
+                body
+              })];
+            });
+          });
+        };
+        RecordClient2.prototype.delete = function(recordType, id) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request("".concat(this.baseUrl, "/").concat(recordType, "/").concat(id), {
+                method: "DELETE"
+              })];
+            });
+          });
+        };
+        RecordClient2.prototype.upsert = function(recordType, externalIdField, externalIdValue, body) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request("".concat(this.baseUrl, "/").concat(recordType, "/eid:").concat(externalIdField, "=").concat(externalIdValue), { method: "PUT", body })];
+            });
+          });
+        };
+        return RecordClient2;
+      })()
+    );
+    exports$1.RecordClient = RecordClient;
   }
-  /**
-   * Execute a query and return a single row, or null if not found.
-   *
-   * @example
-   * ```ts
-   * const customer = await client.suiteql.queryOne<Customer>(
-   *   'SELECT id, companyname FROM customer WHERE id = 123'
-   * );
-   * ```
-   */
-  async queryOne(sql, options) {
-    const result = await this.query(sql, { ...options, maxRows: 1 });
-    return result.items[0] ?? null;
-  }
-  /**
-   * Execute a query and yield pages as an async generator.
-   * Useful for streaming large result sets without holding everything in memory.
-   *
-   * @example
-   * ```ts
-   * for await (const page of client.suiteql.queryPages<Transaction>(
-   *   'SELECT id, tranid, total FROM transaction',
-   *   { pageSize: 500 }
-   * )) {
-   *   await processBatch(page);
-   * }
-   * ```
-   */
-  async *queryPages(sql, options = {}) {
-    const {
-      pageSize = 1e3,
-      offset: startOffset = 0,
-      maxRows = Infinity,
-      timeout
-    } = options;
-    let currentOffset = startOffset;
-    let totalYielded = 0;
-    while (true) {
-      const effectiveLimit = Math.min(pageSize, maxRows - totalYielded);
-      if (effectiveLimit <= 0) return;
-      const url = `${this.baseUrl}?limit=${effectiveLimit}&offset=${currentOffset}`;
-      const response = await this.transport.request(url, {
-        method: "POST",
-        body: { q: sql },
-        headers: { Prefer: "transient" },
-        timeout
+});
+
+// src/restlets/restlet-client.js
+var require_restlet_client = __commonJS({
+  "src/restlets/restlet-client.js"(exports$1) {
+    var __awaiter = exports$1 && exports$1.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
-      const page = response.data;
-      if (page.items.length === 0) return;
-      yield page.items;
-      totalYielded += page.items.length;
-      const hasMore = page.hasMore || currentOffset + page.items.length < page.totalResults;
-      if (!hasMore || totalYielded >= maxRows) return;
-      currentOffset += page.items.length;
-    }
+    };
+    var __generator = exports$1 && exports$1.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.RestletClient = void 0;
+    var RestletClient = (
+      /** @class */
+      (function() {
+        function RestletClient2(transport, accountId) {
+          this.transport = transport;
+          var normalizedId = accountId.toLowerCase().replace(/_/g, "-");
+          this.baseUrl = "https://".concat(normalizedId, ".restlets.api.netsuite.com/app/site/hosting/restlet.nl");
+        }
+        RestletClient2.prototype.call = function(restlet, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            var searchParams, _i, _a, _b, key, value, url;
+            return __generator(this, function(_c) {
+              searchParams = new URLSearchParams({
+                script: String(restlet.script),
+                deploy: String(restlet.deploy)
+              });
+              if (restlet.params) {
+                for (_i = 0, _a = Object.entries(restlet.params); _i < _a.length; _i++) {
+                  _b = _a[_i], key = _b[0], value = _b[1];
+                  searchParams.set(key, String(value));
+                }
+              }
+              url = "".concat(this.baseUrl, "?").concat(searchParams.toString());
+              return [2, this.transport.request(url, options)];
+            });
+          });
+        };
+        return RestletClient2;
+      })()
+    );
+    exports$1.RestletClient = RestletClient;
   }
-};
+});
 
-// src/records/record-client.ts
-var RecordClient = class {
-  transport;
-  baseUrl;
-  constructor(transport, accountId) {
-    this.transport = transport;
-    const normalizedId = accountId.toLowerCase().replace(/_/g, "-");
-    this.baseUrl = `https://${normalizedId}.suitetalk.api.netsuite.com/services/rest/record/v1`;
-  }
-  /** Get a record by type and internal ID */
-  async get(recordType, id, options) {
-    const params = new URLSearchParams();
-    if (options?.fields?.length) {
-      params.set("fields", options.fields.join(","));
-    }
-    if (options?.expandSubResources) {
-      params.set("expandSubResources", "true");
-    }
-    const qs = params.toString();
-    const url = `${this.baseUrl}/${recordType}/${id}${qs ? `?${qs}` : ""}`;
-    return this.transport.request(url);
-  }
-  /** List records of a given type */
-  async list(recordType, options) {
-    const params = new URLSearchParams();
-    if (options?.limit != null) params.set("limit", String(options.limit));
-    if (options?.offset != null) params.set("offset", String(options.offset));
-    if (options?.fields?.length) params.set("fields", options.fields.join(","));
-    if (options?.expandSubResources) params.set("expandSubResources", "true");
-    if (options?.query) {
-      for (const [key, value] of Object.entries(options.query)) {
-        params.set(key, value);
+// src/utils/validation.js
+var require_validation = __commonJS({
+  "src/utils/validation.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.validateConfig = validateConfig2;
+    function validateConfig2(config) {
+      var errors = [];
+      if (!config || typeof config !== "object") {
+        return ["Config must be a non-null object"];
+      }
+      var c = config;
+      if (!c.auth || typeof c.auth !== "object") {
+        errors.push("auth is required and must be an object");
+      } else {
+        var auth = c.auth;
+        var requiredFields = ["consumerKey", "consumerSecret", "tokenKey", "tokenSecret", "realm"];
+        for (var _i = 0, requiredFields_1 = requiredFields; _i < requiredFields_1.length; _i++) {
+          var field = requiredFields_1[_i];
+          if (!auth[field] || typeof auth[field] !== "string") {
+            errors.push("auth.".concat(field, " is required and must be a non-empty string"));
+          }
+        }
       }
+      if (!c.accountId || typeof c.accountId !== "string") {
+        errors.push("accountId is required and must be a non-empty string");
+      }
+      return errors;
     }
-    const qs = params.toString();
-    const url = `${this.baseUrl}/${recordType}${qs ? `?${qs}` : ""}`;
-    return this.transport.request(url);
-  }
-  /** Create a new record */
-  async create(recordType, body) {
-    return this.transport.request(`${this.baseUrl}/${recordType}`, {
-      method: "POST",
-      body
-    });
-  }
-  /** Update an existing record (partial update via PATCH) */
-  async update(recordType, id, body) {
-    return this.transport.request(`${this.baseUrl}/${recordType}/${id}`, {
-      method: "PATCH",
-      body
-    });
   }
-  /** Replace an existing record (full replace via PUT) */
-  async replace(recordType, id, body) {
-    return this.transport.request(`${this.baseUrl}/${recordType}/${id}`, {
-      method: "PUT",
-      body
-    });
-  }
-  /** Delete a record */
-  async delete(recordType, id) {
-    return this.transport.request(`${this.baseUrl}/${recordType}/${id}`, {
-      method: "DELETE"
-    });
-  }
-  /** Upsert: create or update based on external ID */
-  async upsert(recordType, externalIdField, externalIdValue, body) {
-    return this.transport.request(
-      `${this.baseUrl}/${recordType}/eid:${externalIdField}=${externalIdValue}`,
-      { method: "PUT", body }
+});
+
+// src/client.js
+var require_client = __commonJS({
+  "src/client.js"(exports$1) {
+    var __assign = exports$1 && exports$1.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __awaiter = exports$1 && exports$1.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports$1 && exports$1.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.NetSuiteClient = void 0;
+    var http_transport_js_1 = require_http_transport();
+    var suiteql_client_js_1 = require_suiteql_client();
+    var record_client_js_1 = require_record_client();
+    var restlet_client_js_1 = require_restlet_client();
+    var validation_js_1 = require_validation();
+    var NetSuiteClient2 = (
+      /** @class */
+      (function() {
+        function NetSuiteClient3(config) {
+          var errors = (0, validation_js_1.validateConfig)(config);
+          if (errors.length > 0) {
+            throw new Error("Invalid NetSuite configuration:\n  - ".concat(errors.join("\n  - ")));
+          }
+          this.transport = new http_transport_js_1.HttpTransport(config);
+          this.suiteql = new suiteql_client_js_1.SuiteQLClient(this.transport, config.accountId);
+          this.records = new record_client_js_1.RecordClient(this.transport, config.accountId);
+          this.restlets = new restlet_client_js_1.RestletClient(this.transport, config.accountId);
+        }
+        NetSuiteClient3.prototype.use = function(middleware) {
+          this.transport.use(middleware);
+          return this;
+        };
+        NetSuiteClient3.prototype.request = function(url, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request(url, options)];
+            });
+          });
+        };
+        NetSuiteClient3.prototype.get = function(url, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request(url, __assign(__assign({}, options), { method: "GET" }))];
+            });
+          });
+        };
+        NetSuiteClient3.prototype.post = function(url, body, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request(url, __assign(__assign({}, options), { method: "POST", body }))];
+            });
+          });
+        };
+        NetSuiteClient3.prototype.put = function(url, body, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request(url, __assign(__assign({}, options), { method: "PUT", body }))];
+            });
+          });
+        };
+        NetSuiteClient3.prototype.patch = function(url, body, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request(url, __assign(__assign({}, options), { method: "PATCH", body }))];
+            });
+          });
+        };
+        NetSuiteClient3.prototype.delete = function(url, options) {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.transport.request(url, __assign(__assign({}, options), { method: "DELETE" }))];
+            });
+          });
+        };
+        return NetSuiteClient3;
+      })()
     );
+    exports$1.NetSuiteClient = NetSuiteClient2;
   }
-};
+});
 
-// src/restlets/restlet-client.ts
-var RestletClient = class {
-  transport;
-  baseUrl;
-  constructor(transport, accountId) {
-    this.transport = transport;
-    const normalizedId = accountId.toLowerCase().replace(/_/g, "-");
-    this.baseUrl = `https://${normalizedId}.restlets.api.netsuite.com/app/site/hosting/restlet.nl`;
-  }
-  /** Execute a RESTlet call */
-  async call(restlet, options) {
-    const searchParams = new URLSearchParams({
-      script: String(restlet.script),
-      deploy: String(restlet.deploy)
-    });
-    if (restlet.params) {
-      for (const [key, value] of Object.entries(restlet.params)) {
-        searchParams.set(key, String(value));
+// src/suiteql/query-builder.js
+var require_query_builder = __commonJS({
+  "src/suiteql/query-builder.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.SuiteQLBuilder = void 0;
+    exports$1.suiteql = suiteql2;
+    var SuiteQLBuilder2 = (
+      /** @class */
+      (function() {
+        function SuiteQLBuilder3() {
+          this._select = [];
+          this._from = "";
+          this._joins = [];
+          this._where = [];
+          this._groupBy = [];
+          this._orderBy = [];
+          this._having = [];
+        }
+        SuiteQLBuilder3.prototype.select = function() {
+          var _a;
+          var columns = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            columns[_i] = arguments[_i];
+          }
+          (_a = this._select).push.apply(_a, columns);
+          return this;
+        };
+        SuiteQLBuilder3.prototype.from = function(table, alias) {
+          this._from = alias ? "".concat(table, " ").concat(alias) : table;
+          return this;
+        };
+        SuiteQLBuilder3.prototype.join = function(table, condition, type) {
+          if (type === void 0) {
+            type = "INNER";
+          }
+          this._joins.push("".concat(type, " JOIN ").concat(table, " ON ").concat(condition));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.leftJoin = function(table, condition) {
+          return this.join(table, condition, "LEFT");
+        };
+        SuiteQLBuilder3.prototype.rightJoin = function(table, condition) {
+          return this.join(table, condition, "RIGHT");
+        };
+        SuiteQLBuilder3.prototype.where = function(condition) {
+          this._where.push(condition);
+          return this;
+        };
+        SuiteQLBuilder3.prototype.whereEquals = function(column, value) {
+          this._where.push("".concat(column, " = ").concat(escapeValue(value)));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.whereNotEquals = function(column, value) {
+          this._where.push("".concat(column, " != ").concat(escapeValue(value)));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.whereIn = function(column, values) {
+          var escaped = values.map(escapeValue);
+          this._where.push("".concat(column, " IN (").concat(escaped.join(", "), ")"));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.whereNull = function(column) {
+          this._where.push("".concat(column, " IS NULL"));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.whereNotNull = function(column) {
+          this._where.push("".concat(column, " IS NOT NULL"));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.whereBetween = function(column, start, end) {
+          this._where.push("".concat(column, " BETWEEN ").concat(escapeValue(start), " AND ").concat(escapeValue(end)));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.whereLike = function(column, pattern) {
+          this._where.push("".concat(column, " LIKE ").concat(escapeValue(pattern)));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.groupBy = function() {
+          var _a;
+          var columns = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            columns[_i] = arguments[_i];
+          }
+          (_a = this._groupBy).push.apply(_a, columns);
+          return this;
+        };
+        SuiteQLBuilder3.prototype.having = function(condition) {
+          this._having.push(condition);
+          return this;
+        };
+        SuiteQLBuilder3.prototype.orderBy = function(column, direction) {
+          if (direction === void 0) {
+            direction = "ASC";
+          }
+          this._orderBy.push("".concat(column, " ").concat(direction));
+          return this;
+        };
+        SuiteQLBuilder3.prototype.build = function() {
+          if (this._select.length === 0) {
+            throw new Error("SuiteQLBuilder: SELECT clause is required");
+          }
+          if (!this._from) {
+            throw new Error("SuiteQLBuilder: FROM clause is required");
+          }
+          var parts = [
+            "SELECT ".concat(this._select.join(", ")),
+            "FROM ".concat(this._from)
+          ];
+          if (this._joins.length > 0) {
+            parts.push(this._joins.join(" "));
+          }
+          if (this._where.length > 0) {
+            parts.push("WHERE ".concat(this._where.join(" AND ")));
+          }
+          if (this._groupBy.length > 0) {
+            parts.push("GROUP BY ".concat(this._groupBy.join(", ")));
+          }
+          if (this._having.length > 0) {
+            parts.push("HAVING ".concat(this._having.join(" AND ")));
+          }
+          if (this._orderBy.length > 0) {
+            parts.push("ORDER BY ".concat(this._orderBy.join(", ")));
+          }
+          return parts.join(" ");
+        };
+        SuiteQLBuilder3.prototype.toString = function() {
+          return this.build();
+        };
+        return SuiteQLBuilder3;
+      })()
+    );
+    exports$1.SuiteQLBuilder = SuiteQLBuilder2;
+    function escapeValue(value) {
+      if (typeof value === "number") {
+        return String(value);
+      }
+      if (typeof value === "boolean") {
+        return value ? "'T'" : "'F'";
       }
+      var escaped = value.replace(/'/g, "''");
+      return "'".concat(escaped, "'");
+    }
+    function suiteql2() {
+      return new SuiteQLBuilder2();
     }
-    const url = `${this.baseUrl}?${searchParams.toString()}`;
-    return this.transport.request(url, options);
   }
-};
+});
 
-// src/utils/validation.ts
-function validateConfig(config) {
-  const errors = [];
-  if (!config || typeof config !== "object") {
-    return ["Config must be a non-null object"];
-  }
-  const c = config;
-  if (!c.auth || typeof c.auth !== "object") {
-    errors.push("auth is required and must be an object");
-  } else {
-    const auth = c.auth;
-    const requiredFields = ["consumerKey", "consumerSecret", "tokenKey", "tokenSecret", "realm"];
-    for (const field of requiredFields) {
-      if (!auth[field] || typeof auth[field] !== "string") {
-        errors.push(`auth.${field} is required and must be a non-empty string`);
+// src/utils/response-cache.js
+var require_response_cache = __commonJS({
+  "src/utils/response-cache.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.ResponseCache = void 0;
+    exports$1.createCacheKey = createCacheKey2;
+    var ResponseCache2 = (
+      /** @class */
+      (function() {
+        function ResponseCache3() {
+          this.cache = /* @__PURE__ */ new Map();
+        }
+        ResponseCache3.prototype.get = function(key) {
+          var entry = this.cache.get(key);
+          if (!entry)
+            return null;
+          if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return null;
+          }
+          return entry.data;
+        };
+        ResponseCache3.prototype.set = function(key, data, ttlSeconds) {
+          this.cache.set(key, {
+            data,
+            expiresAt: Date.now() + ttlSeconds * 1e3
+          });
+        };
+        ResponseCache3.prototype.delete = function(key) {
+          return this.cache.delete(key);
+        };
+        ResponseCache3.prototype.clear = function() {
+          this.cache.clear();
+        };
+        Object.defineProperty(ResponseCache3.prototype, "size", {
+          /** Get the number of entries (including expired). */
+          get: function() {
+            return this.cache.size;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        return ResponseCache3;
+      })()
+    );
+    exports$1.ResponseCache = ResponseCache2;
+    function createCacheKey2(url, method, params) {
+      var base = "".concat(method, ":").concat(url);
+      if (params) {
+        return "".concat(base, ":").concat(JSON.stringify(params));
       }
+      return base;
     }
   }
-  if (!c.accountId || typeof c.accountId !== "string") {
-    errors.push("accountId is required and must be a non-empty string");
-  }
-  return errors;
-}
+});
 
-// src/client.ts
-var NetSuiteClient = class {
-  /** SuiteQL query execution and builder */
-  suiteql;
-  /** REST Record API CRUD */
-  records;
-  /** RESTlet caller */
-  restlets;
-  transport;
-  constructor(config) {
-    const errors = validateConfig(config);
-    if (errors.length > 0) {
-      throw new Error(`Invalid NetSuite configuration:
-  - ${errors.join("\n  - ")}`);
-    }
-    this.transport = new HttpTransport(config);
-    this.suiteql = new SuiteQLClient(this.transport, config.accountId);
-    this.records = new RecordClient(this.transport, config.accountId);
-    this.restlets = new RestletClient(this.transport, config.accountId);
-  }
-  /** Add middleware to all requests. Returns `this` for chaining. */
-  use(middleware) {
-    this.transport.use(middleware);
-    return this;
-  }
-  /** Make a raw HTTP request (escape hatch for custom endpoints). */
-  async request(url, options) {
-    return this.transport.request(url, options);
-  }
-  /** Convenience: GET request */
-  async get(url, options) {
-    return this.transport.request(url, { ...options, method: "GET" });
-  }
-  /** Convenience: POST request */
-  async post(url, body, options) {
-    return this.transport.request(url, { ...options, method: "POST", body });
-  }
-  /** Convenience: PUT request */
-  async put(url, body, options) {
-    return this.transport.request(url, { ...options, method: "PUT", body });
-  }
-  /** Convenience: PATCH request */
-  async patch(url, body, options) {
-    return this.transport.request(url, { ...options, method: "PATCH", body });
-  }
-  /** Convenience: DELETE request */
-  async delete(url, options) {
-    return this.transport.request(url, { ...options, method: "DELETE" });
+// src/utils/rate-limiter.js
+var require_rate_limiter = __commonJS({
+  "src/utils/rate-limiter.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.RateLimiter = void 0;
+    var RateLimiter2 = (
+      /** @class */
+      (function() {
+        function RateLimiter3(maxRequests, windowMs) {
+          if (maxRequests === void 0) {
+            maxRequests = 100;
+          }
+          if (windowMs === void 0) {
+            windowMs = 6e4;
+          }
+          this.timestamps = [];
+          this.maxRequests = maxRequests;
+          this.windowMs = windowMs;
+        }
+        RateLimiter3.prototype.canMakeRequest = function() {
+          this.pruneExpired();
+          return this.timestamps.length < this.maxRequests;
+        };
+        RateLimiter3.prototype.recordRequest = function() {
+          this.pruneExpired();
+          this.timestamps.push(Date.now());
+        };
+        RateLimiter3.prototype.getRemainingRequests = function() {
+          this.pruneExpired();
+          return Math.max(0, this.maxRequests - this.timestamps.length);
+        };
+        RateLimiter3.prototype.getTimeUntilNextSlot = function() {
+          this.pruneExpired();
+          if (this.timestamps.length < this.maxRequests)
+            return 0;
+          var oldest = this.timestamps[0];
+          return Math.max(0, oldest + this.windowMs - Date.now());
+        };
+        RateLimiter3.prototype.pruneExpired = function() {
+          var cutoff = Date.now() - this.windowMs;
+          while (this.timestamps.length > 0 && this.timestamps[0] <= cutoff) {
+            this.timestamps.shift();
+          }
+        };
+        return RateLimiter3;
+      })()
+    );
+    exports$1.RateLimiter = RateLimiter2;
   }
-};
+});
 
-// src/suiteql/query-builder.ts
-var SuiteQLBuilder = class {
-  _select = [];
-  _from = "";
-  _joins = [];
-  _where = [];
-  _groupBy = [];
-  _orderBy = [];
-  _having = [];
-  /** Add columns to SELECT clause */
-  select(...columns) {
-    this._select.push(...columns);
-    return this;
-  }
-  /** Set the FROM table, with optional alias */
-  from(table, alias) {
-    this._from = alias ? `${table} ${alias}` : table;
-    return this;
-  }
-  /** Add a JOIN clause */
-  join(table, condition, type = "INNER") {
-    this._joins.push(`${type} JOIN ${table} ON ${condition}`);
-    return this;
-  }
-  /** Add a LEFT JOIN clause */
-  leftJoin(table, condition) {
-    return this.join(table, condition, "LEFT");
-  }
-  /** Add a RIGHT JOIN clause */
-  rightJoin(table, condition) {
-    return this.join(table, condition, "RIGHT");
-  }
-  /** Add a raw WHERE condition */
-  where(condition) {
-    this._where.push(condition);
-    return this;
-  }
-  /** Add a WHERE column = value condition. Values are escaped. */
-  whereEquals(column, value) {
-    this._where.push(`${column} = ${escapeValue(value)}`);
-    return this;
-  }
-  /** Add a WHERE column != value condition. Values are escaped. */
-  whereNotEquals(column, value) {
-    this._where.push(`${column} != ${escapeValue(value)}`);
-    return this;
-  }
-  /** Add a WHERE column IN (...) condition. Values are escaped. */
-  whereIn(column, values) {
-    const escaped = values.map(escapeValue);
-    this._where.push(`${column} IN (${escaped.join(", ")})`);
-    return this;
-  }
-  /** Add a WHERE column IS NULL condition */
-  whereNull(column) {
-    this._where.push(`${column} IS NULL`);
-    return this;
-  }
-  /** Add a WHERE column IS NOT NULL condition */
-  whereNotNull(column) {
-    this._where.push(`${column} IS NOT NULL`);
-    return this;
-  }
-  /** Add a WHERE column BETWEEN start AND end condition. Values are escaped. */
-  whereBetween(column, start, end) {
-    this._where.push(`${column} BETWEEN ${escapeValue(start)} AND ${escapeValue(end)}`);
-    return this;
-  }
-  /** Add a WHERE column LIKE pattern condition. Value is escaped. */
-  whereLike(column, pattern) {
-    this._where.push(`${column} LIKE ${escapeValue(pattern)}`);
-    return this;
-  }
-  /** Add columns to GROUP BY clause */
-  groupBy(...columns) {
-    this._groupBy.push(...columns);
-    return this;
-  }
-  /** Add a HAVING condition (used with GROUP BY) */
-  having(condition) {
-    this._having.push(condition);
-    return this;
-  }
-  /** Add a column to ORDER BY clause */
-  orderBy(column, direction = "ASC") {
-    this._orderBy.push(`${column} ${direction}`);
-    return this;
-  }
-  /** Build the SQL string. Throws if SELECT or FROM is missing. */
-  build() {
-    if (this._select.length === 0) {
-      throw new Error("SuiteQLBuilder: SELECT clause is required");
-    }
-    if (!this._from) {
-      throw new Error("SuiteQLBuilder: FROM clause is required");
-    }
-    const parts = [
-      `SELECT ${this._select.join(", ")}`,
-      `FROM ${this._from}`
-    ];
-    if (this._joins.length > 0) {
-      parts.push(this._joins.join(" "));
+// src/utils/date.js
+var require_date = __commonJS({
+  "src/utils/date.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.formatNetSuiteDate = formatNetSuiteDate2;
+    exports$1.parseNetSuiteDate = parseNetSuiteDate2;
+    function formatNetSuiteDate2(date) {
+      var year = date.getFullYear();
+      var month = String(date.getMonth() + 1).padStart(2, "0");
+      var day = String(date.getDate()).padStart(2, "0");
+      return "".concat(year, "-").concat(month, "-").concat(day);
     }
-    if (this._where.length > 0) {
-      parts.push(`WHERE ${this._where.join(" AND ")}`);
-    }
-    if (this._groupBy.length > 0) {
-      parts.push(`GROUP BY ${this._groupBy.join(", ")}`);
-    }
-    if (this._having.length > 0) {
-      parts.push(`HAVING ${this._having.join(" AND ")}`);
-    }
-    if (this._orderBy.length > 0) {
-      parts.push(`ORDER BY ${this._orderBy.join(", ")}`);
+    function parseNetSuiteDate2(dateString) {
+      if (dateString.includes("/")) {
+        var _a = dateString.split("/"), month_1 = _a[0], day_1 = _a[1], year_1 = _a[2];
+        return new Date(Number(year_1), Number(month_1) - 1, Number(day_1));
+      }
+      var _b = dateString.split("-"), year = _b[0], month = _b[1], day = _b[2];
+      return new Date(Number(year), Number(month) - 1, Number(day));
     }
-    return parts.join(" ");
-  }
-  /** Alias for build() */
-  toString() {
-    return this.build();
-  }
-};
-function escapeValue(value) {
-  if (typeof value === "number") {
-    return String(value);
-  }
-  if (typeof value === "boolean") {
-    return value ? "'T'" : "'F'";
   }
-  const escaped = value.replace(/'/g, "''");
-  return `'${escaped}'`;
-}
-function suiteql() {
-  return new SuiteQLBuilder();
-}
+});
 
-// src/utils/response-cache.ts
-var ResponseCache = class {
-  cache = /* @__PURE__ */ new Map();
-  /** Get a cached value, or null if not found or expired. */
-  get(key) {
-    const entry = this.cache.get(key);
-    if (!entry) return null;
-    if (Date.now() > entry.expiresAt) {
-      this.cache.delete(key);
-      return null;
+// src/utils/error-parser.js
+var require_error_parser = __commonJS({
+  "src/utils/error-parser.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.parseNetSuiteError = parseNetSuiteError2;
+    function parseNetSuiteError2(error) {
+      var _a, _b;
+      if (!error || typeof error !== "object") {
+        return { message: String(error) };
+      }
+      var e = error;
+      if (e.title || e.detail) {
+        return {
+          message: String((_b = (_a = e.detail) !== null && _a !== void 0 ? _a : e.title) !== null && _b !== void 0 ? _b : "Unknown error"),
+          code: e["o:errorCode"],
+          details: e
+        };
+      }
+      if (e.message) {
+        return {
+          message: String(e.message),
+          code: e.code
+        };
+      }
+      return { message: JSON.stringify(error) };
     }
-    return entry.data;
-  }
-  /** Set a cached value with a TTL in seconds. */
-  set(key, data, ttlSeconds) {
-    this.cache.set(key, {
-      data,
-      expiresAt: Date.now() + ttlSeconds * 1e3
-    });
-  }
-  /** Delete a specific cache entry. */
-  delete(key) {
-    return this.cache.delete(key);
-  }
-  /** Clear all cached entries. */
-  clear() {
-    this.cache.clear();
-  }
-  /** Get the number of entries (including expired). */
-  get size() {
-    return this.cache.size;
-  }
-};
-function createCacheKey(url, method, params) {
-  const base = `${method}:${url}`;
-  if (params) {
-    return `${base}:${JSON.stringify(params)}`;
   }
-  return base;
-}
+});
 
-// src/utils/rate-limiter.ts
-var RateLimiter = class {
-  timestamps = [];
-  maxRequests;
-  windowMs;
-  constructor(maxRequests = 100, windowMs = 6e4) {
-    this.maxRequests = maxRequests;
-    this.windowMs = windowMs;
-  }
-  /** Check if a request can be made without exceeding the limit. */
-  canMakeRequest() {
-    this.pruneExpired();
-    return this.timestamps.length < this.maxRequests;
-  }
-  /** Record that a request was made. */
-  recordRequest() {
-    this.pruneExpired();
-    this.timestamps.push(Date.now());
-  }
-  /** Get the number of remaining requests in the current window. */
-  getRemainingRequests() {
-    this.pruneExpired();
-    return Math.max(0, this.maxRequests - this.timestamps.length);
-  }
-  /** Get ms until the next request slot opens. Returns 0 if a slot is available. */
-  getTimeUntilNextSlot() {
-    this.pruneExpired();
-    if (this.timestamps.length < this.maxRequests) return 0;
-    const oldest = this.timestamps[0];
-    return Math.max(0, oldest + this.windowMs - Date.now());
-  }
-  pruneExpired() {
-    const cutoff = Date.now() - this.windowMs;
-    while (this.timestamps.length > 0 && this.timestamps[0] <= cutoff) {
-      this.timestamps.shift();
+// src/utils/url-builder.js
+var require_url_builder = __commonJS({
+  "src/utils/url-builder.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.normalizeAccountId = normalizeAccountId2;
+    exports$1.buildSuiteTalkUrl = buildSuiteTalkUrl;
+    exports$1.buildRestletUrl = buildRestletUrl;
+    function normalizeAccountId2(accountId) {
+      return accountId.toLowerCase().replace(/_/g, "-");
+    }
+    function buildSuiteTalkUrl(accountId) {
+      return "https://".concat(normalizeAccountId2(accountId), ".suitetalk.api.netsuite.com");
+    }
+    function buildRestletUrl(accountId) {
+      return "https://".concat(normalizeAccountId2(accountId), ".restlets.api.netsuite.com");
     }
   }
-};
+});
 
-// src/utils/date.ts
-function formatNetSuiteDate(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-function parseNetSuiteDate(dateString) {
-  if (dateString.includes("/")) {
-    const [month2, day2, year2] = dateString.split("/");
-    return new Date(Number(year2), Number(month2) - 1, Number(day2));
+// src/index.ts
+var import_client = __toESM(require_client());
+var import_query_builder = __toESM(require_query_builder());
+var import_errors = __toESM(require_errors());
+var SOAP_ONLY_FIELDS = {
+  assemblyItem: ["taxSchedule"],
+  inventoryItem: ["taxSchedule"],
+  nonInventoryItem: ["taxSchedule"],
+  kitItem: ["taxSchedule"],
+  serviceItem: ["taxSchedule"],
+  otherChargeItem: ["taxSchedule"],
+  lotNumberedInventoryItem: ["taxSchedule"],
+  serializedInventoryItem: ["taxSchedule"]
+};
+var SOAP_RECORD_TYPES = {
+  assemblyItem: { type: "AssemblyItem", namespace: "listAcct" },
+  inventoryItem: { type: "InventoryItem", namespace: "listAcct" },
+  nonInventoryItem: { type: "NonInventorySaleItem", namespace: "listAcct" },
+  kitItem: { type: "KitItem", namespace: "listAcct" },
+  serviceItem: { type: "ServiceSaleItem", namespace: "listAcct" },
+  otherChargeItem: { type: "OtherChargeSaleItem", namespace: "listAcct" },
+  lotNumberedInventoryItem: { type: "LotNumberedInventoryItem", namespace: "listAcct" },
+  serializedInventoryItem: { type: "SerializedInventoryItem", namespace: "listAcct" },
+  customer: { type: "Customer", namespace: "listRel" },
+  vendor: { type: "Vendor", namespace: "listRel" },
+  salesOrder: { type: "SalesOrder", namespace: "tranSales" },
+  purchaseOrder: { type: "PurchaseOrder", namespace: "tranPurch" },
+  invoice: { type: "Invoice", namespace: "tranSales" }
+};
+var NS_NAMESPACES = {
+  listAcct: "urn:accounting_2024_1.lists.webservices.netsuite.com",
+  listRel: "urn:relationships_2024_1.lists.webservices.netsuite.com",
+  tranSales: "urn:sales_2024_1.transactions.webservices.netsuite.com",
+  tranPurch: "urn:purchases_2024_1.transactions.webservices.netsuite.com",
+  core: "urn:core_2024_1.platform.webservices.netsuite.com",
+  messages: "urn:messages_2024_1.platform.webservices.netsuite.com"
+};
+function extractSoapOnlyFields(recordType, body) {
+  const knownSoapFields = SOAP_ONLY_FIELDS[recordType] ?? [];
+  const soapFields = {};
+  const restBody = {};
+  for (const [key, value] of Object.entries(body)) {
+    if (knownSoapFields.includes(key)) {
+      soapFields[key] = value;
+    } else {
+      restBody[key] = value;
+    }
   }
-  const [year, month, day] = dateString.split("-");
-  return new Date(Number(year), Number(month) - 1, Number(day));
+  return { soapFields, restBody };
 }
-
-// src/utils/error-parser.ts
-function parseNetSuiteError(error) {
-  if (!error || typeof error !== "object") {
-    return { message: String(error) };
+var SoapFieldClient = class {
+  auth;
+  accountId;
+  constructor(auth, accountId) {
+    this.auth = auth;
+    this.accountId = accountId;
   }
-  const e = error;
-  if (e.title || e.detail) {
+  /**
+   * Update SOAP-only fields on an existing record.
+   */
+  async updateFields(recordType, internalId, fields) {
+    const soapType = SOAP_RECORD_TYPES[recordType];
+    if (!soapType) {
+      return {
+        success: false,
+        error: `Unsupported SOAP record type: ${recordType}`
+      };
+    }
+    const fieldXml = this.buildFieldXml(fields, soapType.namespace);
+    const envelope = this.buildUpdateEnvelope(soapType, internalId, fieldXml);
+    const normalizedId = this.accountId.toLowerCase().replace(/_/g, "-");
+    const soapUrl = `https://${normalizedId}.suitetalk.api.netsuite.com/services/NetSuitePort_2024_1`;
+    const response = await fetch(soapUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        SOAPAction: "update"
+      },
+      body: envelope
+    });
+    const responseText = await response.text();
+    if (!response.ok) {
+      const errorMatch = responseText.match(/<faultstring>(.*?)<\/faultstring>/s);
+      return {
+        success: false,
+        error: errorMatch?.[1] ?? `SOAP HTTP ${response.status}: ${response.statusText}`
+      };
+    }
+    const successMatch = responseText.match(/isSuccess="true"/);
+    if (successMatch) {
+      return { success: true, internalId };
+    }
+    const detailMatch = responseText.match(/<platformCore:message>(.*?)<\/platformCore:message>/s);
     return {
-      message: String(e.detail ?? e.title ?? "Unknown error"),
-      code: e["o:errorCode"],
-      details: e
+      success: false,
+      internalId,
+      error: detailMatch?.[1] ?? "SOAP update returned without success flag"
     };
   }
-  if (e.message) {
+  /**
+   * Create a record via SOAP (full creation, not just field update).
+   */
+  async addRecord(recordType, fields) {
+    const soapType = SOAP_RECORD_TYPES[recordType];
+    if (!soapType) {
+      return {
+        success: false,
+        error: `Unsupported SOAP record type: ${recordType}`
+      };
+    }
+    const fieldXml = this.buildFieldXml(fields, soapType.namespace);
+    const envelope = this.buildAddEnvelope(soapType, fieldXml);
+    const normalizedId = this.accountId.toLowerCase().replace(/_/g, "-");
+    const soapUrl = `https://${normalizedId}.suitetalk.api.netsuite.com/services/NetSuitePort_2024_1`;
+    const response = await fetch(soapUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        SOAPAction: "add"
+      },
+      body: envelope
+    });
+    const responseText = await response.text();
+    if (!response.ok) {
+      const errorMatch = responseText.match(/<faultstring>(.*?)<\/faultstring>/s);
+      return {
+        success: false,
+        error: errorMatch?.[1] ?? `SOAP HTTP ${response.status}: ${response.statusText}`
+      };
+    }
+    const successMatch = responseText.match(/isSuccess="true"/);
+    const idMatch = responseText.match(/internalId="(\d+)"/);
+    if (successMatch) {
+      return { success: true, internalId: idMatch?.[1] };
+    }
+    const detailMatch = responseText.match(/<platformCore:message>(.*?)<\/platformCore:message>/s);
     return {
-      message: String(e.message),
-      code: e.code
+      success: false,
+      error: detailMatch?.[1] ?? "SOAP add returned without success flag"
     };
   }
-  return { message: JSON.stringify(error) };
-}
+  // ─── Private helpers ──────────────────────────────────────────────────────
+  buildFieldXml(fields, ns) {
+    const prefix = ns;
+    const parts = [];
+    for (const [key, value] of Object.entries(fields)) {
+      if (value === null || value === void 0) continue;
+      if (typeof value === "object" && value !== null && "id" in value) {
+        parts.push(`<${prefix}:${key} internalId="${value.id}"/>`);
+      } else if (typeof value === "object" && value !== null && "items" in value) {
+        const items = value.items;
+        const listParts = [];
+        for (const item of items) {
+          Object.entries(item).map(([k, v]) => {
+            if (typeof v === "object" && v !== null && "id" in v) {
+              return `<${prefix}:${k} internalId="${v.id}"/>`;
+            }
+            return `<${prefix}:${k}>${String(v)}</${prefix}:${k}>`;
+          }).join("\n              ");
+          listParts.push(`<core:recordRef internalId="${item.id ?? ""}"/>`);
+        }
+        parts.push(`<${prefix}:${key}List>
+            ${listParts.join("\n            ")}
+          </${prefix}:${key}List>`);
+      } else if (typeof value === "boolean") {
+        parts.push(`<${prefix}:${key}>${value}</${prefix}:${key}>`);
+      } else {
+        parts.push(`<${prefix}:${key}>${String(value)}</${prefix}:${key}>`);
+      }
+    }
+    return parts.join("\n          ");
+  }
+  buildTokenPassport() {
+    const nonce = randomBytes(16).toString("hex");
+    const timestamp = Math.floor(Date.now() / 1e3).toString();
+    const baseString = `${this.accountId}&${this.auth.consumerKey}&${this.auth.tokenKey}&${nonce}&${timestamp}`;
+    const signingKey = `${this.auth.consumerSecret}&${this.auth.tokenSecret}`;
+    const signature = createHmac("sha256", signingKey).update(baseString).digest("base64");
+    return `
+      <urn:tokenPassport>
+        <core:account>${this.accountId}</core:account>
+        <core:consumerKey>${this.auth.consumerKey}</core:consumerKey>
+        <core:token>${this.auth.tokenKey}</core:token>
+        <core:nonce>${nonce}</core:nonce>
+        <core:timestamp>${timestamp}</core:timestamp>
+        <core:signature algorithm="HMAC-SHA256">${signature}</core:signature>
+      </urn:tokenPassport>`;
+  }
+  buildUpdateEnvelope(soapType, internalId, fieldXml) {
+    const nsUri = NS_NAMESPACES[soapType.namespace];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope
+    xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
+    xmlns:urn="${NS_NAMESPACES.messages}"
+    xmlns:core="${NS_NAMESPACES.core}"
+    xmlns:${soapType.namespace}="${nsUri}"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <soapenv:Header>${this.buildTokenPassport()}
+  </soapenv:Header>
+  <soapenv:Body>
+    <urn:update>
+      <urn:record xsi:type="${soapType.namespace}:${soapType.type}" internalId="${internalId}">
+          ${fieldXml}
+      </urn:record>
+    </urn:update>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+  }
+  buildAddEnvelope(soapType, fieldXml) {
+    const nsUri = NS_NAMESPACES[soapType.namespace];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope
+    xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
+    xmlns:urn="${NS_NAMESPACES.messages}"
+    xmlns:core="${NS_NAMESPACES.core}"
+    xmlns:${soapType.namespace}="${nsUri}"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <soapenv:Header>${this.buildTokenPassport()}
+  </soapenv:Header>
+  <soapenv:Body>
+    <urn:add>
+      <urn:record xsi:type="${soapType.namespace}:${soapType.type}">
+          ${fieldXml}
+      </urn:record>
+    </urn:add>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+  }
+};
 
-// src/utils/url-builder.ts
-function normalizeAccountId(accountId) {
-  return accountId.toLowerCase().replace(/_/g, "-");
-}
+// src/index.ts
+var import_response_cache = __toESM(require_response_cache());
+var import_rate_limiter = __toESM(require_rate_limiter());
+var import_validation = __toESM(require_validation());
+var import_date = __toESM(require_date());
+var import_error_parser = __toESM(require_error_parser());
+var import_url_builder = __toESM(require_url_builder());
+var export_NetSuiteClient = import_client.NetSuiteClient;
+var export_NetSuiteError = import_errors.NetSuiteError;
+var export_RateLimiter = import_rate_limiter.RateLimiter;
+var export_ResponseCache = import_response_cache.ResponseCache;
+var export_SuiteQLBuilder = import_query_builder.SuiteQLBuilder;
+var export_createCacheKey = import_response_cache.createCacheKey;
+var export_formatNetSuiteDate = import_date.formatNetSuiteDate;
+var export_normalizeAccountId = import_url_builder.normalizeAccountId;
+var export_parseNetSuiteDate = import_date.parseNetSuiteDate;
+var export_parseNetSuiteError = import_error_parser.parseNetSuiteError;
+var export_suiteql = import_query_builder.suiteql;
+var export_validateConfig = import_validation.validateConfig;
 
-export { NetSuiteClient, NetSuiteError, RateLimiter, ResponseCache, SuiteQLBuilder, createCacheKey, formatNetSuiteDate, normalizeAccountId, parseNetSuiteDate, parseNetSuiteError, suiteql, validateConfig };
+export { export_NetSuiteClient as NetSuiteClient, export_NetSuiteError as NetSuiteError, export_RateLimiter as RateLimiter, export_ResponseCache as ResponseCache, SOAP_ONLY_FIELDS, SoapFieldClient, export_SuiteQLBuilder as SuiteQLBuilder, export_createCacheKey as createCacheKey, extractSoapOnlyFields, export_formatNetSuiteDate as formatNetSuiteDate, export_normalizeAccountId as normalizeAccountId, export_parseNetSuiteDate as parseNetSuiteDate, export_parseNetSuiteError as parseNetSuiteError, export_suiteql as suiteql, export_validateConfig as validateConfig };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map