@outseta/n8n-nodes-outseta 0.0.0

package/dist/nodes/Outseta/Outseta.node.js

@@ -0,0 +1,1623 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/nodes/Outseta/Outseta.node.ts
+var exports_Outseta_node = {};
+__export(exports_Outseta_node, {
+  Outseta: () => Outseta
+});
+module.exports = __toCommonJS(exports_Outseta_node);
+var import_n8n_workflow = require("n8n-workflow");
+
+// ../../node_modules/ky/distribution/errors/HTTPError.js
+class HTTPError extends Error {
+  response;
+  request;
+  options;
+  constructor(response, request, options) {
+    const code = response.status || response.status === 0 ? response.status : "";
+    const title = response.statusText ?? "";
+    const status = `${code} ${title}`.trim();
+    const reason = status ? `status code ${status}` : "an unknown error";
+    super(`Request failed with ${reason}: ${request.method} ${request.url}`);
+    this.name = "HTTPError";
+    this.response = response;
+    this.request = request;
+    this.options = options;
+  }
+}
+
+// ../../node_modules/ky/distribution/errors/NonError.js
+class NonError extends Error {
+  name = "NonError";
+  value;
+  constructor(value) {
+    let message = "Non-error value was thrown";
+    try {
+      if (typeof value === "string") {
+        message = value;
+      } else if (value && typeof value === "object" && "message" in value && typeof value.message === "string") {
+        message = value.message;
+      }
+    } catch {}
+    super(message);
+    this.value = value;
+  }
+}
+
+// ../../node_modules/ky/distribution/errors/ForceRetryError.js
+class ForceRetryError extends Error {
+  name = "ForceRetryError";
+  customDelay;
+  code;
+  customRequest;
+  constructor(options) {
+    const cause = options?.cause ? options.cause instanceof Error ? options.cause : new NonError(options.cause) : undefined;
+    super(options?.code ? `Forced retry: ${options.code}` : "Forced retry", cause ? { cause } : undefined);
+    this.customDelay = options?.delay;
+    this.code = options?.code;
+    this.customRequest = options?.request;
+  }
+}
+
+// ../../node_modules/ky/distribution/core/constants.js
+var supportsRequestStreams = (() => {
+  let duplexAccessed = false;
+  let hasContentType = false;
+  const supportsReadableStream = typeof globalThis.ReadableStream === "function";
+  const supportsRequest = typeof globalThis.Request === "function";
+  if (supportsReadableStream && supportsRequest) {
+    try {
+      hasContentType = new globalThis.Request("https://empty.invalid", {
+        body: new globalThis.ReadableStream,
+        method: "POST",
+        get duplex() {
+          duplexAccessed = true;
+          return "half";
+        }
+      }).headers.has("Content-Type");
+    } catch (error) {
+      if (error instanceof Error && error.message === "unsupported BodyInit type") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  return duplexAccessed && !hasContentType;
+})();
+var supportsAbortController = typeof globalThis.AbortController === "function";
+var supportsAbortSignal = typeof globalThis.AbortSignal === "function" && typeof globalThis.AbortSignal.any === "function";
+var supportsResponseStreams = typeof globalThis.ReadableStream === "function";
+var supportsFormData = typeof globalThis.FormData === "function";
+var requestMethods = ["get", "post", "put", "patch", "head", "delete"];
+var validate = () => {
+  return;
+};
+validate();
+var responseTypes = {
+  json: "application/json",
+  text: "text/*",
+  formData: "multipart/form-data",
+  arrayBuffer: "*/*",
+  blob: "*/*",
+  bytes: "*/*"
+};
+var maxSafeTimeout = 2147483647;
+var usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
+var stop = Symbol("stop");
+
+class RetryMarker {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+}
+var retry = (options) => new RetryMarker(options);
+var kyOptionKeys = {
+  json: true,
+  parseJson: true,
+  stringifyJson: true,
+  searchParams: true,
+  prefixUrl: true,
+  retry: true,
+  timeout: true,
+  hooks: true,
+  throwHttpErrors: true,
+  onDownloadProgress: true,
+  onUploadProgress: true,
+  fetch: true,
+  context: true
+};
+var vendorSpecificOptions = {
+  next: true
+};
+var requestOptionsRegistry = {
+  method: true,
+  headers: true,
+  body: true,
+  mode: true,
+  credentials: true,
+  cache: true,
+  redirect: true,
+  referrer: true,
+  referrerPolicy: true,
+  integrity: true,
+  keepalive: true,
+  signal: true,
+  window: true,
+  duplex: true
+};
+
+// ../../node_modules/ky/distribution/utils/body.js
+var getBodySize = (body) => {
+  if (!body) {
+    return 0;
+  }
+  if (body instanceof FormData) {
+    let size = 0;
+    for (const [key, value] of body) {
+      size += usualFormBoundarySize;
+      size += new TextEncoder().encode(`Content-Disposition: form-data; name="${key}"`).length;
+      size += typeof value === "string" ? new TextEncoder().encode(value).length : value.size;
+    }
+    return size;
+  }
+  if (body instanceof Blob) {
+    return body.size;
+  }
+  if (body instanceof ArrayBuffer) {
+    return body.byteLength;
+  }
+  if (typeof body === "string") {
+    return new TextEncoder().encode(body).length;
+  }
+  if (body instanceof URLSearchParams) {
+    return new TextEncoder().encode(body.toString()).length;
+  }
+  if ("byteLength" in body) {
+    return body.byteLength;
+  }
+  if (typeof body === "object" && body !== null) {
+    try {
+      const jsonString = JSON.stringify(body);
+      return new TextEncoder().encode(jsonString).length;
+    } catch {
+      return 0;
+    }
+  }
+  return 0;
+};
+var withProgress = (stream, totalBytes, onProgress) => {
+  let previousChunk;
+  let transferredBytes = 0;
+  return stream.pipeThrough(new TransformStream({
+    transform(currentChunk, controller) {
+      controller.enqueue(currentChunk);
+      if (previousChunk) {
+        transferredBytes += previousChunk.byteLength;
+        let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+        if (percent >= 1) {
+          percent = 1 - Number.EPSILON;
+        }
+        onProgress?.({ percent, totalBytes: Math.max(totalBytes, transferredBytes), transferredBytes }, previousChunk);
+      }
+      previousChunk = currentChunk;
+    },
+    flush() {
+      if (previousChunk) {
+        transferredBytes += previousChunk.byteLength;
+        onProgress?.({ percent: 1, totalBytes: Math.max(totalBytes, transferredBytes), transferredBytes }, previousChunk);
+      }
+    }
+  }));
+};
+var streamResponse = (response, onDownloadProgress) => {
+  if (!response.body) {
+    return response;
+  }
+  if (response.status === 204) {
+    return new Response(null, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  const totalBytes = Math.max(0, Number(response.headers.get("content-length")) || 0);
+  return new Response(withProgress(response.body, totalBytes, onDownloadProgress), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+};
+var streamRequest = (request, onUploadProgress, originalBody) => {
+  if (!request.body) {
+    return request;
+  }
+  const totalBytes = getBodySize(originalBody ?? request.body);
+  return new Request(request, {
+    duplex: "half",
+    body: withProgress(request.body, totalBytes, onUploadProgress)
+  });
+};
+
+// ../../node_modules/ky/distribution/utils/is.js
+var isObject = (value) => value !== null && typeof value === "object";
+
+// ../../node_modules/ky/distribution/utils/merge.js
+var validateAndMerge = (...sources) => {
+  for (const source of sources) {
+    if ((!isObject(source) || Array.isArray(source)) && source !== undefined) {
+      throw new TypeError("The `options` argument must be an object");
+    }
+  }
+  return deepMerge({}, ...sources);
+};
+var mergeHeaders = (source1 = {}, source2 = {}) => {
+  const result = new globalThis.Headers(source1);
+  const isHeadersInstance = source2 instanceof globalThis.Headers;
+  const source = new globalThis.Headers(source2);
+  for (const [key, value] of source.entries()) {
+    if (isHeadersInstance && value === "undefined" || value === undefined) {
+      result.delete(key);
+    } else {
+      result.set(key, value);
+    }
+  }
+  return result;
+};
+function newHookValue(original, incoming, property) {
+  return Object.hasOwn(incoming, property) && incoming[property] === undefined ? [] : deepMerge(original[property] ?? [], incoming[property] ?? []);
+}
+var mergeHooks = (original = {}, incoming = {}) => ({
+  beforeRequest: newHookValue(original, incoming, "beforeRequest"),
+  beforeRetry: newHookValue(original, incoming, "beforeRetry"),
+  afterResponse: newHookValue(original, incoming, "afterResponse"),
+  beforeError: newHookValue(original, incoming, "beforeError")
+});
+var appendSearchParameters = (target, source) => {
+  const result = new URLSearchParams;
+  for (const input of [target, source]) {
+    if (input === undefined) {
+      continue;
+    }
+    if (input instanceof URLSearchParams) {
+      for (const [key, value] of input.entries()) {
+        result.append(key, value);
+      }
+    } else if (Array.isArray(input)) {
+      for (const pair of input) {
+        if (!Array.isArray(pair) || pair.length !== 2) {
+          throw new TypeError("Array search parameters must be provided in [[key, value], ...] format");
+        }
+        result.append(String(pair[0]), String(pair[1]));
+      }
+    } else if (isObject(input)) {
+      for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined) {
+          result.append(key, String(value));
+        }
+      }
+    } else {
+      const parameters = new URLSearchParams(input);
+      for (const [key, value] of parameters.entries()) {
+        result.append(key, value);
+      }
+    }
+  }
+  return result;
+};
+var deepMerge = (...sources) => {
+  let returnValue = {};
+  let headers = {};
+  let hooks = {};
+  let searchParameters;
+  const signals = [];
+  for (const source of sources) {
+    if (Array.isArray(source)) {
+      if (!Array.isArray(returnValue)) {
+        returnValue = [];
+      }
+      returnValue = [...returnValue, ...source];
+    } else if (isObject(source)) {
+      for (let [key, value] of Object.entries(source)) {
+        if (key === "signal" && value instanceof globalThis.AbortSignal) {
+          signals.push(value);
+          continue;
+        }
+        if (key === "context") {
+          if (value !== undefined && value !== null && (!isObject(value) || Array.isArray(value))) {
+            throw new TypeError("The `context` option must be an object");
+          }
+          returnValue = {
+            ...returnValue,
+            context: value === undefined || value === null ? {} : { ...returnValue.context, ...value }
+          };
+          continue;
+        }
+        if (key === "searchParams") {
+          if (value === undefined || value === null) {
+            searchParameters = undefined;
+          } else {
+            searchParameters = searchParameters === undefined ? value : appendSearchParameters(searchParameters, value);
+          }
+          continue;
+        }
+        if (isObject(value) && key in returnValue) {
+          value = deepMerge(returnValue[key], value);
+        }
+        returnValue = { ...returnValue, [key]: value };
+      }
+      if (isObject(source.hooks)) {
+        hooks = mergeHooks(hooks, source.hooks);
+        returnValue.hooks = hooks;
+      }
+      if (isObject(source.headers)) {
+        headers = mergeHeaders(headers, source.headers);
+        returnValue.headers = headers;
+      }
+    }
+  }
+  if (searchParameters !== undefined) {
+    returnValue.searchParams = searchParameters;
+  }
+  if (signals.length > 0) {
+    if (signals.length === 1) {
+      returnValue.signal = signals[0];
+    } else if (supportsAbortSignal) {
+      returnValue.signal = AbortSignal.any(signals);
+    } else {
+      returnValue.signal = signals.at(-1);
+    }
+  }
+  return returnValue;
+};
+
+// ../../node_modules/ky/distribution/utils/normalize.js
+var normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
+var retryMethods = ["get", "put", "head", "delete", "options", "trace"];
+var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+var retryAfterStatusCodes = [413, 429, 503];
+var defaultRetryOptions = {
+  limit: 2,
+  methods: retryMethods,
+  statusCodes: retryStatusCodes,
+  afterStatusCodes: retryAfterStatusCodes,
+  maxRetryAfter: Number.POSITIVE_INFINITY,
+  backoffLimit: Number.POSITIVE_INFINITY,
+  delay: (attemptCount) => 0.3 * 2 ** (attemptCount - 1) * 1000,
+  jitter: undefined,
+  retryOnTimeout: false
+};
+var normalizeRetryOptions = (retry2 = {}) => {
+  if (typeof retry2 === "number") {
+    return {
+      ...defaultRetryOptions,
+      limit: retry2
+    };
+  }
+  if (retry2.methods && !Array.isArray(retry2.methods)) {
+    throw new Error("retry.methods must be an array");
+  }
+  retry2.methods &&= retry2.methods.map((method) => method.toLowerCase());
+  if (retry2.statusCodes && !Array.isArray(retry2.statusCodes)) {
+    throw new Error("retry.statusCodes must be an array");
+  }
+  const normalizedRetry = Object.fromEntries(Object.entries(retry2).filter(([, value]) => value !== undefined));
+  return {
+    ...defaultRetryOptions,
+    ...normalizedRetry
+  };
+};
+
+// ../../node_modules/ky/distribution/errors/TimeoutError.js
+class TimeoutError extends Error {
+  request;
+  constructor(request) {
+    super(`Request timed out: ${request.method} ${request.url}`);
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+}
+
+// ../../node_modules/ky/distribution/utils/timeout.js
+async function timeout(request, init, abortController, options) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      if (abortController) {
+        abortController.abort();
+      }
+      reject(new TimeoutError(request));
+    }, options.timeout);
+    options.fetch(request, init).then(resolve).catch(reject).then(() => {
+      clearTimeout(timeoutId);
+    });
+  });
+}
+
+// ../../node_modules/ky/distribution/utils/delay.js
+async function delay(ms, { signal }) {
+  return new Promise((resolve, reject) => {
+    if (signal) {
+      signal.throwIfAborted();
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    function abortHandler() {
+      clearTimeout(timeoutId);
+      reject(signal.reason);
+    }
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", abortHandler);
+      resolve();
+    }, ms);
+  });
+}
+
+// ../../node_modules/ky/distribution/utils/options.js
+var findUnknownOptions = (request, options) => {
+  const unknownOptions = {};
+  for (const key in options) {
+    if (!Object.hasOwn(options, key)) {
+      continue;
+    }
+    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && (!(key in request) || (key in vendorSpecificOptions))) {
+      unknownOptions[key] = options[key];
+    }
+  }
+  return unknownOptions;
+};
+var hasSearchParameters = (search) => {
+  if (search === undefined) {
+    return false;
+  }
+  if (Array.isArray(search)) {
+    return search.length > 0;
+  }
+  if (search instanceof URLSearchParams) {
+    return search.size > 0;
+  }
+  if (typeof search === "object") {
+    return Object.keys(search).length > 0;
+  }
+  if (typeof search === "string") {
+    return search.trim().length > 0;
+  }
+  return Boolean(search);
+};
+
+// ../../node_modules/ky/distribution/utils/type-guards.js
+function isHTTPError(error) {
+  return error instanceof HTTPError || error?.name === HTTPError.name;
+}
+function isTimeoutError(error) {
+  return error instanceof TimeoutError || error?.name === TimeoutError.name;
+}
+
+// ../../node_modules/ky/distribution/core/Ky.js
+class Ky {
+  static create(input, options) {
+    const ky = new Ky(input, options);
+    const function_ = async () => {
+      if (typeof ky.#options.timeout === "number" && ky.#options.timeout > maxSafeTimeout) {
+        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+      }
+      await Promise.resolve();
+      let response = await ky.#fetch();
+      for (const hook of ky.#options.hooks.afterResponse) {
+        const clonedResponse = ky.#decorateResponse(response.clone());
+        let modifiedResponse;
+        try {
+          modifiedResponse = await hook(ky.request, ky.#getNormalizedOptions(), clonedResponse, { retryCount: ky.#retryCount });
+        } catch (error) {
+          ky.#cancelResponseBody(clonedResponse);
+          ky.#cancelResponseBody(response);
+          throw error;
+        }
+        if (modifiedResponse instanceof RetryMarker) {
+          ky.#cancelResponseBody(clonedResponse);
+          ky.#cancelResponseBody(response);
+          throw new ForceRetryError(modifiedResponse.options);
+        }
+        const nextResponse = modifiedResponse instanceof globalThis.Response ? modifiedResponse : response;
+        if (clonedResponse !== nextResponse) {
+          ky.#cancelResponseBody(clonedResponse);
+        }
+        if (response !== nextResponse) {
+          ky.#cancelResponseBody(response);
+        }
+        response = nextResponse;
+      }
+      ky.#decorateResponse(response);
+      if (!response.ok && (typeof ky.#options.throwHttpErrors === "function" ? ky.#options.throwHttpErrors(response.status) : ky.#options.throwHttpErrors)) {
+        let error = new HTTPError(response, ky.request, ky.#getNormalizedOptions());
+        for (const hook of ky.#options.hooks.beforeError) {
+          error = await hook(error, { retryCount: ky.#retryCount });
+        }
+        throw error;
+      }
+      if (ky.#options.onDownloadProgress) {
+        if (typeof ky.#options.onDownloadProgress !== "function") {
+          throw new TypeError("The `onDownloadProgress` option must be a function");
+        }
+        if (!supportsResponseStreams) {
+          throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
+        }
+        const progressResponse = response.clone();
+        ky.#cancelResponseBody(response);
+        return streamResponse(progressResponse, ky.#options.onDownloadProgress);
+      }
+      return response;
+    };
+    const result = ky.#retry(function_).finally(() => {
+      const originalRequest = ky.#originalRequest;
+      ky.#cancelBody(originalRequest?.body ?? undefined);
+      ky.#cancelBody(ky.request.body ?? undefined);
+    });
+    for (const [type, mimeType] of Object.entries(responseTypes)) {
+      if (type === "bytes" && typeof globalThis.Response?.prototype?.bytes !== "function") {
+        continue;
+      }
+      result[type] = async () => {
+        ky.request.headers.set("accept", ky.request.headers.get("accept") || mimeType);
+        const response = await result;
+        if (type === "json") {
+          if (response.status === 204) {
+            return "";
+          }
+          const text = await response.text();
+          if (text === "") {
+            return "";
+          }
+          if (options.parseJson) {
+            return options.parseJson(text);
+          }
+          return JSON.parse(text);
+        }
+        return response[type]();
+      };
+    }
+    return result;
+  }
+  static #normalizeSearchParams(searchParams) {
+    if (searchParams && typeof searchParams === "object" && !Array.isArray(searchParams) && !(searchParams instanceof URLSearchParams)) {
+      return Object.fromEntries(Object.entries(searchParams).filter(([, value]) => value !== undefined));
+    }
+    return searchParams;
+  }
+  request;
+  #abortController;
+  #retryCount = 0;
+  #input;
+  #options;
+  #originalRequest;
+  #userProvidedAbortSignal;
+  #cachedNormalizedOptions;
+  constructor(input, options = {}) {
+    this.#input = input;
+    this.#options = {
+      ...options,
+      headers: mergeHeaders(this.#input.headers, options.headers),
+      hooks: mergeHooks({
+        beforeRequest: [],
+        beforeRetry: [],
+        beforeError: [],
+        afterResponse: []
+      }, options.hooks),
+      method: normalizeRequestMethod(options.method ?? this.#input.method ?? "GET"),
+      prefixUrl: String(options.prefixUrl || ""),
+      retry: normalizeRetryOptions(options.retry),
+      throwHttpErrors: options.throwHttpErrors ?? true,
+      timeout: options.timeout ?? 1e4,
+      fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
+      context: options.context ?? {}
+    };
+    if (typeof this.#input !== "string" && !(this.#input instanceof URL || this.#input instanceof globalThis.Request)) {
+      throw new TypeError("`input` must be a string, URL, or Request");
+    }
+    if (this.#options.prefixUrl && typeof this.#input === "string") {
+      if (this.#input.startsWith("/")) {
+        throw new Error("`input` must not begin with a slash when using `prefixUrl`");
+      }
+      if (!this.#options.prefixUrl.endsWith("/")) {
+        this.#options.prefixUrl += "/";
+      }
+      this.#input = this.#options.prefixUrl + this.#input;
+    }
+    if (supportsAbortController && supportsAbortSignal) {
+      this.#userProvidedAbortSignal = this.#options.signal ?? this.#input.signal;
+      this.#abortController = new globalThis.AbortController;
+      this.#options.signal = this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
+    }
+    if (supportsRequestStreams) {
+      this.#options.duplex = "half";
+    }
+    if (this.#options.json !== undefined) {
+      this.#options.body = this.#options.stringifyJson?.(this.#options.json) ?? JSON.stringify(this.#options.json);
+      this.#options.headers.set("content-type", this.#options.headers.get("content-type") ?? "application/json");
+    }
+    const userProvidedContentType = options.headers && new globalThis.Headers(options.headers).has("content-type");
+    if (this.#input instanceof globalThis.Request && (supportsFormData && this.#options.body instanceof globalThis.FormData || this.#options.body instanceof URLSearchParams) && !userProvidedContentType) {
+      this.#options.headers.delete("content-type");
+    }
+    this.request = new globalThis.Request(this.#input, this.#options);
+    if (hasSearchParameters(this.#options.searchParams)) {
+      const textSearchParams = typeof this.#options.searchParams === "string" ? this.#options.searchParams.replace(/^\?/, "") : new URLSearchParams(Ky.#normalizeSearchParams(this.#options.searchParams)).toString();
+      const searchParams = "?" + textSearchParams;
+      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
+      this.request = new globalThis.Request(url, this.#options);
+    }
+    if (this.#options.onUploadProgress) {
+      if (typeof this.#options.onUploadProgress !== "function") {
+        throw new TypeError("The `onUploadProgress` option must be a function");
+      }
+      if (!supportsRequestStreams) {
+        throw new Error("Request streams are not supported in your environment. The `duplex` option for `Request` is not available.");
+      }
+      this.request = this.#wrapRequestWithUploadProgress(this.request, this.#options.body ?? undefined);
+    }
+  }
+  #calculateDelay() {
+    const retryDelay = this.#options.retry.delay(this.#retryCount);
+    let jitteredDelay = retryDelay;
+    if (this.#options.retry.jitter === true) {
+      jitteredDelay = Math.random() * retryDelay;
+    } else if (typeof this.#options.retry.jitter === "function") {
+      jitteredDelay = this.#options.retry.jitter(retryDelay);
+      if (!Number.isFinite(jitteredDelay) || jitteredDelay < 0) {
+        jitteredDelay = retryDelay;
+      }
+    }
+    const backoffLimit = this.#options.retry.backoffLimit ?? Number.POSITIVE_INFINITY;
+    return Math.min(backoffLimit, jitteredDelay);
+  }
+  async#calculateRetryDelay(error) {
+    this.#retryCount++;
+    if (this.#retryCount > this.#options.retry.limit) {
+      throw error;
+    }
+    const errorObject = error instanceof Error ? error : new NonError(error);
+    if (errorObject instanceof ForceRetryError) {
+      return errorObject.customDelay ?? this.#calculateDelay();
+    }
+    if (!this.#options.retry.methods.includes(this.request.method.toLowerCase())) {
+      throw error;
+    }
+    if (this.#options.retry.shouldRetry !== undefined) {
+      const result = await this.#options.retry.shouldRetry({ error: errorObject, retryCount: this.#retryCount });
+      if (result === false) {
+        throw error;
+      }
+      if (result === true) {
+        return this.#calculateDelay();
+      }
+    }
+    if (isTimeoutError(error) && !this.#options.retry.retryOnTimeout) {
+      throw error;
+    }
+    if (isHTTPError(error)) {
+      if (!this.#options.retry.statusCodes.includes(error.response.status)) {
+        throw error;
+      }
+      const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Retry-After") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
+      if (retryAfter && this.#options.retry.afterStatusCodes.includes(error.response.status)) {
+        let after = Number(retryAfter) * 1000;
+        if (Number.isNaN(after)) {
+          after = Date.parse(retryAfter) - Date.now();
+        } else if (after >= Date.parse("2024-01-01")) {
+          after -= Date.now();
+        }
+        const max = this.#options.retry.maxRetryAfter ?? after;
+        return after < max ? after : max;
+      }
+      if (error.response.status === 413) {
+        throw error;
+      }
+    }
+    return this.#calculateDelay();
+  }
+  #decorateResponse(response) {
+    if (this.#options.parseJson) {
+      response.json = async () => this.#options.parseJson(await response.text());
+    }
+    return response;
+  }
+  #cancelBody(body) {
+    if (!body) {
+      return;
+    }
+    body.cancel().catch(() => {
+      return;
+    });
+  }
+  #cancelResponseBody(response) {
+    this.#cancelBody(response.body ?? undefined);
+  }
+  async#retry(function_) {
+    try {
+      return await function_();
+    } catch (error) {
+      const ms = Math.min(await this.#calculateRetryDelay(error), maxSafeTimeout);
+      if (this.#retryCount < 1) {
+        throw error;
+      }
+      await delay(ms, this.#userProvidedAbortSignal ? { signal: this.#userProvidedAbortSignal } : {});
+      if (error instanceof ForceRetryError && error.customRequest) {
+        const managedRequest = this.#options.signal ? new globalThis.Request(error.customRequest, { signal: this.#options.signal }) : new globalThis.Request(error.customRequest);
+        this.#assignRequest(managedRequest);
+      }
+      for (const hook of this.#options.hooks.beforeRetry) {
+        const hookResult = await hook({
+          request: this.request,
+          options: this.#getNormalizedOptions(),
+          error,
+          retryCount: this.#retryCount
+        });
+        if (hookResult instanceof globalThis.Request) {
+          this.#assignRequest(hookResult);
+          break;
+        }
+        if (hookResult instanceof globalThis.Response) {
+          return hookResult;
+        }
+        if (hookResult === stop) {
+          return;
+        }
+      }
+      return this.#retry(function_);
+    }
+  }
+  async#fetch() {
+    if (this.#abortController?.signal.aborted) {
+      this.#abortController = new globalThis.AbortController;
+      this.#options.signal = this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
+      this.request = new globalThis.Request(this.request, { signal: this.#options.signal });
+    }
+    for (const hook of this.#options.hooks.beforeRequest) {
+      const result = await hook(this.request, this.#getNormalizedOptions(), { retryCount: this.#retryCount });
+      if (result instanceof Response) {
+        return result;
+      }
+      if (result instanceof globalThis.Request) {
+        this.#assignRequest(result);
+        break;
+      }
+    }
+    const nonRequestOptions = findUnknownOptions(this.request, this.#options);
+    this.#originalRequest = this.request;
+    this.request = this.#originalRequest.clone();
+    if (this.#options.timeout === false) {
+      return this.#options.fetch(this.#originalRequest, nonRequestOptions);
+    }
+    return timeout(this.#originalRequest, nonRequestOptions, this.#abortController, this.#options);
+  }
+  #getNormalizedOptions() {
+    if (!this.#cachedNormalizedOptions) {
+      const { hooks, ...normalizedOptions } = this.#options;
+      this.#cachedNormalizedOptions = Object.freeze(normalizedOptions);
+    }
+    return this.#cachedNormalizedOptions;
+  }
+  #assignRequest(request) {
+    this.#cachedNormalizedOptions = undefined;
+    this.request = this.#wrapRequestWithUploadProgress(request);
+  }
+  #wrapRequestWithUploadProgress(request, originalBody) {
+    if (!this.#options.onUploadProgress || !request.body) {
+      return request;
+    }
+    return streamRequest(request, this.#options.onUploadProgress, originalBody ?? this.#options.body ?? undefined);
+  }
+}
+
+// ../../node_modules/ky/distribution/index.js
+/*! MIT License © Sindre Sorhus */
+var createInstance = (defaults) => {
+  const ky = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
+  for (const method of requestMethods) {
+    ky[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));
+  }
+  ky.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
+  ky.extend = (newDefaults) => {
+    if (typeof newDefaults === "function") {
+      newDefaults = newDefaults(defaults ?? {});
+    }
+    return createInstance(validateAndMerge(defaults, newDefaults));
+  };
+  ky.stop = stop;
+  ky.retry = retry;
+  return ky;
+};
+var ky = createInstance();
+var distribution_default = ky;
+
+// ../api-client/dist/index.js
+function createClient(creds) {
+  return distribution_default.create({
+    prefixUrl: `https://${creds.subdomain}.outseta.com/api/v1/`,
+    headers: {
+      Authorization: `Outseta ${creds.apiKey}:${creds.apiSecret}`
+    },
+    retry: { limit: 3, statusCodes: [408, 429, 500, 502, 503, 504] }
+  });
+}
+
+// src/nodes/Outseta/Outseta.node.ts
+class Outseta {
+  description = {
+    displayName: "Outseta",
+    name: "outseta",
+    icon: "file:outseta.svg",
+    group: ["transform"],
+    version: 1,
+    subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+    description: "Interact with the Outseta REST API",
+    defaults: {
+      name: "Outseta"
+    },
+    inputs: [import_n8n_workflow.NodeConnectionTypes.Main],
+    outputs: [import_n8n_workflow.NodeConnectionTypes.Main],
+    credentials: [
+      {
+        name: "outsetaApi",
+        required: true
+      }
+    ],
+    properties: [
+      {
+        displayName: "Resource",
+        name: "resource",
+        type: "options",
+        noDataExpression: true,
+        options: [
+          { name: "Account", value: "account" },
+          { name: "Person", value: "person" },
+          { name: "Plan", value: "plan" },
+          { name: "Plan Family", value: "planFamily" },
+          { name: "Subscription", value: "subscription" },
+          { name: "Email List", value: "emailList" }
+        ],
+        default: "account"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: { show: { resource: ["account"] } },
+        options: [
+          { name: "Get Many", value: "getMany", description: "Get many accounts", action: "Get many accounts" },
+          { name: "Register", value: "register", description: "Register a new account (person + account + subscription)", action: "Register an account" },
+          { name: "Add Person", value: "addPerson", description: "Add an existing person to an account", action: "Add person to account" }
+        ],
+        default: "getMany"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: { show: { resource: ["person"] } },
+        options: [
+          { name: "Get Many", value: "getMany", description: "Get many people", action: "Get many people" },
+          { name: "Create", value: "create", description: "Create a person", action: "Create a person" }
+        ],
+        default: "getMany"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: { show: { resource: ["plan"] } },
+        options: [
+          { name: "Get Many", value: "getMany", description: "Get many plans", action: "Get many plans" },
+          { name: "Create", value: "create", description: "Create a plan", action: "Create a plan" }
+        ],
+        default: "getMany"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: { show: { resource: ["planFamily"] } },
+        options: [
+          { name: "Get Many", value: "getMany", description: "Get many plan families", action: "Get many plan families" },
+          { name: "Create", value: "create", description: "Create a plan family", action: "Create a plan family" }
+        ],
+        default: "getMany"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: { show: { resource: ["subscription"] } },
+        options: [
+          { name: "Preview Change", value: "previewChange", description: "Preview a subscription plan change", action: "Preview subscription change" },
+          { name: "Change", value: "change", description: "Change a subscription plan", action: "Change subscription" }
+        ],
+        default: "previewChange"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: { show: { resource: ["emailList"] } },
+        options: [
+          { name: "Get Many", value: "getMany", description: "Get many email lists", action: "Get many email lists" },
+          { name: "Create", value: "create", description: "Create an email list", action: "Create an email list" },
+          { name: "Get Subscribers", value: "getSubscribers", description: "Get subscribers of an email list", action: "Get email list subscribers" },
+          { name: "Subscribe Person", value: "subscribePerson", description: "Subscribe a person to an email list", action: "Subscribe person to email list" }
+        ],
+        default: "getMany"
+      },
+      {
+        displayName: "Search Term",
+        name: "q",
+        type: "string",
+        default: "",
+        description: "Search term to filter results",
+        displayOptions: { show: { operation: ["getMany"] } }
+      },
+      {
+        displayName: "Limit",
+        name: "limit",
+        type: "number",
+        typeOptions: { minValue: 1, maxValue: 100 },
+        default: 25,
+        description: "Max number of results to return",
+        displayOptions: { show: { operation: ["getMany"] } }
+      },
+      {
+        displayName: "Offset",
+        name: "offset",
+        type: "number",
+        typeOptions: { minValue: 0 },
+        default: 0,
+        description: "Page offset (0-based)",
+        displayOptions: { show: { operation: ["getMany"] } }
+      },
+      {
+        displayName: "Fields",
+        name: "fields",
+        type: "string",
+        default: "*,*.*",
+        description: 'Fields to include in the response. Use "*" for root fields, "*,*.*" for nested objects, or specific paths like "Uid,Name,CurrentSubscription.Plan.*".',
+        displayOptions: { show: { operation: ["getMany"] } }
+      },
+      {
+        displayName: "Order By",
+        name: "orderBy",
+        type: "string",
+        default: "",
+        description: 'Field to order results by (e.g. "Name", "Created")',
+        displayOptions: { show: { operation: ["getMany"] } }
+      },
+      {
+        displayName: "Order Direction",
+        name: "orderDirection",
+        type: "options",
+        options: [
+          { name: "Ascending", value: "ASC" },
+          { name: "Descending", value: "DESC" }
+        ],
+        default: "ASC",
+        displayOptions: { show: { operation: ["getMany"] } }
+      },
+      {
+        displayName: "Filters",
+        name: "filters",
+        type: "fixedCollection",
+        typeOptions: { multipleValues: true },
+        default: {},
+        placeholder: "Add Filter",
+        displayOptions: { show: { operation: ["getMany"] } },
+        options: [
+          {
+            name: "filterValues",
+            displayName: "Filter",
+            values: [
+              {
+                displayName: "Field",
+                name: "field",
+                type: "string",
+                default: "",
+                description: "Field name to filter on"
+              },
+              {
+                displayName: "Operator",
+                name: "operator",
+                type: "options",
+                options: [
+                  { name: "Equals", value: "" },
+                  { name: "Greater Than", value: "gt" },
+                  { name: "Greater Than or Equal", value: "gte" },
+                  { name: "Less Than", value: "lt" },
+                  { name: "Less Than or Equal", value: "lte" },
+                  { name: "Not Equal", value: "ne" },
+                  { name: "Is Null", value: "isnull" }
+                ],
+                default: ""
+              },
+              {
+                displayName: "Value",
+                name: "value",
+                type: "string",
+                default: "",
+                description: "Value to filter by"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        displayName: "Email",
+        name: "email",
+        type: "string",
+        placeholder: "name@email.com",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["account"], operation: ["register"] } },
+        description: "Email address of the person signing up"
+      },
+      {
+        displayName: "Plan UID",
+        name: "planUid",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["account"], operation: ["register"] } },
+        description: "The UID of the plan for the subscription"
+      },
+      {
+        displayName: "First Name",
+        name: "firstName",
+        type: "string",
+        default: "",
+        displayOptions: { show: { resource: ["account"], operation: ["register"] } }
+      },
+      {
+        displayName: "Last Name",
+        name: "lastName",
+        type: "string",
+        default: "",
+        displayOptions: { show: { resource: ["account"], operation: ["register"] } }
+      },
+      {
+        displayName: "Account Name",
+        name: "accountName",
+        type: "string",
+        default: "",
+        displayOptions: { show: { resource: ["account"], operation: ["register"] } }
+      },
+      {
+        displayName: "Billing Renewal Term",
+        name: "billingRenewalTerm",
+        type: "options",
+        options: [
+          { name: "Monthly", value: 1 },
+          { name: "Annual", value: 2 },
+          { name: "Quarterly", value: 3 }
+        ],
+        default: 1,
+        displayOptions: { show: { resource: ["account"], operation: ["register"] } }
+      },
+      {
+        displayName: "Account UID",
+        name: "accountUid",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["account"], operation: ["addPerson"] } },
+        description: "UID of the account to add the person to"
+      },
+      {
+        displayName: "Person UID",
+        name: "personUid",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["account"], operation: ["addPerson"] } },
+        description: "UID of the person to add"
+      },
+      {
+        displayName: "Is Primary",
+        name: "isPrimary",
+        type: "boolean",
+        default: false,
+        displayOptions: { show: { resource: ["account"], operation: ["addPerson"] } },
+        description: "Whether this person should be the primary contact"
+      },
+      {
+        displayName: "Send Welcome Email",
+        name: "sendWelcomeEmail",
+        type: "boolean",
+        default: false,
+        displayOptions: { show: { resource: ["account"], operation: ["addPerson"] } }
+      },
+      {
+        displayName: "Email",
+        name: "email",
+        type: "string",
+        placeholder: "name@email.com",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["person"], operation: ["create"] } }
+      },
+      {
+        displayName: "First Name",
+        name: "firstName",
+        type: "string",
+        default: "",
+        displayOptions: { show: { resource: ["person"], operation: ["create"] } }
+      },
+      {
+        displayName: "Last Name",
+        name: "lastName",
+        type: "string",
+        default: "",
+        displayOptions: { show: { resource: ["person"], operation: ["create"] } }
+      },
+      {
+        displayName: "Name",
+        name: "planName",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } },
+        description: "Name of the plan"
+      },
+      {
+        displayName: "Plan Family UID",
+        name: "planFamilyUid",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } }
+      },
+      {
+        displayName: "Is Active",
+        name: "isActive",
+        type: "boolean",
+        default: true,
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } }
+      },
+      {
+        displayName: "Account Registration Mode",
+        name: "accountRegistrationMode",
+        type: "options",
+        options: [
+          { name: "Individual", value: "Individual" },
+          { name: "Team", value: "Team" }
+        ],
+        default: "Individual",
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } }
+      },
+      {
+        displayName: "Trial Period Days",
+        name: "trialPeriodDays",
+        type: "number",
+        default: 0,
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } }
+      },
+      {
+        displayName: "Monthly Rate",
+        name: "monthlyRate",
+        type: "number",
+        typeOptions: { numberPrecision: 2 },
+        default: 0,
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } }
+      },
+      {
+        displayName: "Annual Rate",
+        name: "annualRate",
+        type: "number",
+        typeOptions: { numberPrecision: 2 },
+        default: 0,
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } }
+      },
+      {
+        displayName: "Quarterly Rate",
+        name: "quarterlyRate",
+        type: "number",
+        typeOptions: { numberPrecision: 2 },
+        default: 0,
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } }
+      },
+      {
+        displayName: "One-Time Rate",
+        name: "oneTimeRate",
+        type: "number",
+        typeOptions: { numberPrecision: 2 },
+        default: 0,
+        displayOptions: { show: { resource: ["plan"], operation: ["create"] } }
+      },
+      {
+        displayName: "Name",
+        name: "planFamilyName",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["planFamily"], operation: ["create"] } }
+      },
+      {
+        displayName: "Is Default",
+        name: "isDefault",
+        type: "boolean",
+        default: false,
+        displayOptions: { show: { resource: ["planFamily"], operation: ["create"] } }
+      },
+      {
+        displayName: "Is Active",
+        name: "isActivePlanFamily",
+        type: "boolean",
+        default: true,
+        displayOptions: { show: { resource: ["planFamily"], operation: ["create"] } }
+      },
+      {
+        displayName: "Account UID",
+        name: "accountUid",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["subscription"] } },
+        description: "UID of the account whose subscription to change"
+      },
+      {
+        displayName: "New Plan UID",
+        name: "planUid",
+        type: "string",
+        default: "",
+        displayOptions: { show: { resource: ["subscription"] } },
+        description: "UID of the plan to change to (leave empty to keep current plan)"
+      },
+      {
+        displayName: "Billing Renewal Term",
+        name: "billingRenewalTerm",
+        type: "options",
+        options: [
+          { name: "Keep Current", value: 0 },
+          { name: "Monthly", value: 1 },
+          { name: "Annual", value: 2 },
+          { name: "Quarterly", value: 3 }
+        ],
+        default: 0,
+        displayOptions: { show: { resource: ["subscription"] } },
+        description: "Billing renewal term (0 = keep current)"
+      },
+      {
+        displayName: "Start Immediately",
+        name: "startImmediately",
+        type: "boolean",
+        default: false,
+        displayOptions: { show: { resource: ["subscription"] } }
+      },
+      {
+        displayName: "Name",
+        name: "emailListName",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["emailList"], operation: ["create"] } }
+      },
+      {
+        displayName: "Description",
+        name: "emailListDescription",
+        type: "string",
+        default: "",
+        displayOptions: { show: { resource: ["emailList"], operation: ["create"] } }
+      },
+      {
+        displayName: "Is Internal",
+        name: "isInternal",
+        type: "boolean",
+        default: false,
+        displayOptions: { show: { resource: ["emailList"], operation: ["create"] } },
+        description: "Internal lists do not support double opt-in or welcome emails"
+      },
+      {
+        displayName: "Requires Double Opt-In",
+        name: "requiresDoubleOptIn",
+        type: "boolean",
+        default: true,
+        displayOptions: { show: { resource: ["emailList"], operation: ["create"] } }
+      },
+      {
+        displayName: "Welcome Email",
+        name: "welcomeEmail",
+        type: "fixedCollection",
+        default: {},
+        displayOptions: { show: { resource: ["emailList"], operation: ["create"] } },
+        description: "Optional welcome email configuration (only for non-internal lists)",
+        options: [
+          {
+            name: "welcomeValues",
+            displayName: "Welcome Email",
+            values: [
+              { displayName: "From Name", name: "fromName", type: "string", default: "" },
+              { displayName: "From Email", name: "fromEmail", type: "string", default: "" },
+              { displayName: "Subject", name: "subject", type: "string", default: "" },
+              { displayName: "Body (HTML)", name: "body", type: "string", typeOptions: { rows: 5 }, default: "" }
+            ]
+          }
+        ]
+      },
+      {
+        displayName: "List UID",
+        name: "listUid",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["emailList"], operation: ["getSubscribers"] } }
+      },
+      {
+        displayName: "List UID",
+        name: "listUid",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["emailList"], operation: ["subscribePerson"] } }
+      },
+      {
+        displayName: "Person UID",
+        name: "personUid",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: { show: { resource: ["emailList"], operation: ["subscribePerson"] } }
+      },
+      {
+        displayName: "Send Welcome Email",
+        name: "sendWelcomeEmail",
+        type: "boolean",
+        default: false,
+        displayOptions: { show: { resource: ["emailList"], operation: ["subscribePerson"] } }
+      }
+    ]
+  };
+  async execute() {
+    const items = this.getInputData();
+    const returnData = [];
+    const credentials = await this.getCredentials("outsetaApi");
+    const client = createClient({
+      subdomain: credentials.subdomain,
+      apiKey: credentials.apiKey,
+      apiSecret: credentials.apiSecret
+    });
+    for (let i = 0;i < items.length; i++) {
+      try {
+        const resource = this.getNodeParameter("resource", i);
+        const operation = this.getNodeParameter("operation", i);
+        let responseData;
+        if (resource === "account") {
+          if (operation === "getMany") {
+            responseData = await makeListRequest(client, this, i, "crm/accounts");
+          } else if (operation === "register") {
+            const body = {
+              Name: this.getNodeParameter("accountName", i, "") || undefined,
+              Subscriptions: [
+                {
+                  BillingRenewalTerm: this.getNodeParameter("billingRenewalTerm", i),
+                  Plan: { Uid: this.getNodeParameter("planUid", i) }
+                }
+              ],
+              PersonAccount: [
+                {
+                  IsPrimary: true,
+                  Person: {
+                    Email: this.getNodeParameter("email", i),
+                    FirstName: this.getNodeParameter("firstName", i, "") || undefined,
+                    LastName: this.getNodeParameter("lastName", i, "") || undefined
+                  }
+                }
+              ]
+            };
+            responseData = await request(client, "post", "crm/registrations", body);
+          } else if (operation === "addPerson") {
+            const accountUid = this.getNodeParameter("accountUid", i);
+            const body = {
+              Account: { Uid: accountUid },
+              Person: { Uid: this.getNodeParameter("personUid", i) },
+              IsPrimary: this.getNodeParameter("isPrimary", i)
+            };
+            const searchParams = {
+              sendWelcomeEmail: String(this.getNodeParameter("sendWelcomeEmail", i))
+            };
+            responseData = await request(client, "post", `crm/accounts/${accountUid}/memberships`, body, searchParams);
+          } else {
+            throw new Error(`Unknown operation: ${operation}`);
+          }
+        } else if (resource === "person") {
+          if (operation === "getMany") {
+            responseData = await makeListRequest(client, this, i, "crm/people");
+          } else if (operation === "create") {
+            const body = {
+              Email: this.getNodeParameter("email", i),
+              FirstName: this.getNodeParameter("firstName", i, "") || undefined,
+              LastName: this.getNodeParameter("lastName", i, "") || undefined
+            };
+            responseData = await request(client, "post", "crm/people", body);
+          } else {
+            throw new Error(`Unknown operation: ${operation}`);
+          }
+        } else if (resource === "plan") {
+          if (operation === "getMany") {
+            responseData = await makeListRequest(client, this, i, "billing/plans");
+          } else if (operation === "create") {
+            const body = {
+              Name: this.getNodeParameter("planName", i),
+              PlanFamily: { Uid: this.getNodeParameter("planFamilyUid", i) },
+              IsActive: this.getNodeParameter("isActive", i),
+              AccountRegistrationMode: this.getNodeParameter("accountRegistrationMode", i),
+              TrialPeriodDays: this.getNodeParameter("trialPeriodDays", i, 0) || undefined,
+              MonthlyRate: this.getNodeParameter("monthlyRate", i, 0) || undefined,
+              AnnualRate: this.getNodeParameter("annualRate", i, 0) || undefined,
+              QuarterlyRate: this.getNodeParameter("quarterlyRate", i, 0) || undefined,
+              OneTimeRate: this.getNodeParameter("oneTimeRate", i, 0) || undefined
+            };
+            responseData = await request(client, "post", "billing/plans", body);
+          } else {
+            throw new Error(`Unknown operation: ${operation}`);
+          }
+        } else if (resource === "planFamily") {
+          if (operation === "getMany") {
+            responseData = await makeListRequest(client, this, i, "billing/planfamilies");
+          } else if (operation === "create") {
+            const body = {
+              Name: this.getNodeParameter("planFamilyName", i),
+              IsDefault: this.getNodeParameter("isDefault", i),
+              IsActive: this.getNodeParameter("isActivePlanFamily", i)
+            };
+            responseData = await request(client, "post", "billing/planfamilies", body);
+          } else {
+            throw new Error(`Unknown operation: ${operation}`);
+          }
+        } else if (resource === "subscription") {
+          const accountUid = this.getNodeParameter("accountUid", i);
+          const accountData = await request(client, "get", `crm/accounts/${accountUid}`, undefined, {
+            fields: "Uid,Name,CurrentSubscription.*"
+          });
+          const currentSubscription = accountData.CurrentSubscription;
+          if (!currentSubscription) {
+            throw new Error(`Account ${accountUid} does not have an active subscription`);
+          }
+          const billingRenewalTerm = this.getNodeParameter("billingRenewalTerm", i);
+          const planUid = this.getNodeParameter("planUid", i, "");
+          const body = {
+            Plan: { Uid: planUid || currentSubscription.Plan?.Uid },
+            BillingRenewalTerm: billingRenewalTerm || currentSubscription.BillingRenewalTerm,
+            Account: { Uid: accountUid }
+          };
+          const searchParams = {
+            startImmediately: String(this.getNodeParameter("startImmediately", i))
+          };
+          const subUid = currentSubscription.Uid;
+          const endpoint = operation === "previewChange" ? `billing/subscriptions/${subUid}/changesubscriptionpreview` : `billing/subscriptions/${subUid}/changeSubscription`;
+          responseData = await request(client, "put", endpoint, body, searchParams);
+        } else if (resource === "emailList") {
+          if (operation === "getMany") {
+            responseData = await makeListRequest(client, this, i, "email/lists");
+          } else if (operation === "create") {
+            const body = {
+              Name: this.getNodeParameter("emailListName", i),
+              Description: this.getNodeParameter("emailListDescription", i, "") || undefined,
+              IsInternal: this.getNodeParameter("isInternal", i),
+              RequiresDoubleOptIn: this.getNodeParameter("requiresDoubleOptIn", i)
+            };
+            const welcomeEmail = this.getNodeParameter("welcomeEmail", i, {});
+            const welcomeValues = welcomeEmail.welcomeValues ?? {};
+            if (welcomeValues.fromName) {
+              body.WelcomeFromName = welcomeValues.fromName;
+              body.WelcomeFromEmail = welcomeValues.fromEmail;
+              body.WelcomeSubject = welcomeValues.subject;
+              body.WelcomeBody = welcomeValues.body;
+            }
+            responseData = await request(client, "post", "email/lists", body);
+          } else if (operation === "getSubscribers") {
+            const listUid = this.getNodeParameter("listUid", i);
+            responseData = await request(client, "get", `email/lists/${listUid}/subscriptions`);
+          } else if (operation === "subscribePerson") {
+            const listUid = this.getNodeParameter("listUid", i);
+            const body = {
+              EmailList: { Uid: listUid },
+              Person: { Uid: this.getNodeParameter("personUid", i) },
+              SendWelcomeEmail: this.getNodeParameter("sendWelcomeEmail", i)
+            };
+            responseData = await request(client, "post", `email/lists/${listUid}/subscriptions`, body);
+          } else {
+            throw new Error(`Unknown operation: ${operation}`);
+          }
+        } else {
+          throw new Error(`Unknown resource: ${resource}`);
+        }
+        if (Array.isArray(responseData)) {
+          returnData.push(...responseData.map((item) => ({ json: item })));
+        } else {
+          returnData.push({ json: responseData });
+        }
+      } catch (error) {
+        if (this.continueOnFail()) {
+          returnData.push({
+            json: { error: error.message },
+            pairedItem: { item: i }
+          });
+          continue;
+        }
+        throw error;
+      }
+    }
+    return [returnData];
+  }
+}
+async function request(client, method, endpoint, body, searchParams) {
+  const options = {};
+  if (body)
+    options.json = body;
+  if (searchParams)
+    options.searchParams = searchParams;
+  return await client[method](endpoint, options).json();
+}
+async function makeListRequest(client, ctx, itemIndex, endpoint) {
+  const searchParams = {};
+  const q = ctx.getNodeParameter("q", itemIndex, "");
+  if (q)
+    searchParams.q = q;
+  const limit = ctx.getNodeParameter("limit", itemIndex, 25);
+  searchParams.limit = String(limit);
+  const offset = ctx.getNodeParameter("offset", itemIndex, 0);
+  searchParams.offset = String(offset);
+  const fields = ctx.getNodeParameter("fields", itemIndex, "*,*.*");
+  if (fields)
+    searchParams.fields = fields;
+  const orderBy = ctx.getNodeParameter("orderBy", itemIndex, "");
+  const orderDirection = ctx.getNodeParameter("orderDirection", itemIndex, "ASC");
+  if (orderBy) {
+    searchParams.orderBy = `${orderBy}+${orderDirection}`;
+  }
+  const filtersData = ctx.getNodeParameter("filters", itemIndex, {});
+  const filterValues = filtersData.filterValues ?? [];
+  for (const filter of filterValues) {
+    const field = filter.field;
+    const operator = filter.operator;
+    const value = filter.value;
+    const paramKey = operator ? `${field}__${operator}` : field;
+    searchParams[paramKey] = value;
+  }
+  return await request(client, "get", endpoint, undefined, searchParams);
+}