npm - netsuite-sdk - Versions diffs - 0.1.2 → 0.1.3 - Mend

netsuite-sdk 0.1.2 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/index.js CHANGED Viewed

@@ -1,839 +1,2083 @@
 'use strict';
-var axios = require('axios');
-var http = require('http');
-var https = require('https');
-var OAuth = require('oauth-1.0a');
 var crypto = require('crypto');
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-var axios__default = /*#__PURE__*/_interopDefault(axios);
-var http__default = /*#__PURE__*/_interopDefault(http);
-var https__default = /*#__PURE__*/_interopDefault(https);
-var OAuth__default = /*#__PURE__*/_interopDefault(OAuth);
-// src/transport/http-transport.ts
-function createOAuthSigner(config) {
-  const oauth = new OAuth__default.default({
-    consumer: { key: config.consumerKey, secret: config.consumerSecret },
-    signature_method: "HMAC-SHA256",
-    hash_function: (baseString, key) => crypto.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__default.default.create({
-      timeout: this.config.timeout,
-      headers: {
-        "Content-Type": "application/json",
-        "Accept-Encoding": "gzip, deflate"
-      },
-      httpAgent: new http__default.default.Agent({ keepAlive: true }),
-      httpsAgent: new https__default.default.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 = crypto.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 = crypto.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;
-exports.NetSuiteClient = NetSuiteClient;
-exports.NetSuiteError = NetSuiteError;
-exports.RateLimiter = RateLimiter;
-exports.ResponseCache = ResponseCache;
-exports.SuiteQLBuilder = SuiteQLBuilder;
-exports.createCacheKey = createCacheKey;
-exports.formatNetSuiteDate = formatNetSuiteDate;
-exports.normalizeAccountId = normalizeAccountId;
-exports.parseNetSuiteDate = parseNetSuiteDate;
-exports.parseNetSuiteError = parseNetSuiteError;
-exports.suiteql = suiteql;
-exports.validateConfig = validateConfig;
+exports.NetSuiteClient = export_NetSuiteClient;
+exports.NetSuiteError = export_NetSuiteError;
+exports.RateLimiter = export_RateLimiter;
+exports.ResponseCache = export_ResponseCache;
+exports.SOAP_ONLY_FIELDS = SOAP_ONLY_FIELDS;
+exports.SoapFieldClient = SoapFieldClient;
+exports.SuiteQLBuilder = export_SuiteQLBuilder;
+exports.createCacheKey = export_createCacheKey;
+exports.extractSoapOnlyFields = extractSoapOnlyFields;
+exports.formatNetSuiteDate = export_formatNetSuiteDate;
+exports.normalizeAccountId = export_normalizeAccountId;
+exports.parseNetSuiteDate = export_parseNetSuiteDate;
+exports.parseNetSuiteError = export_parseNetSuiteError;
+exports.suiteql = export_suiteql;
+exports.validateConfig = export_validateConfig;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map