@use-stall/core 0.0.2 → 0.0.3

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+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 __export = (target, all) => {
   for (var name in all)
@@ -15,1305 +17,2140 @@ var __copyProps = (to, from, except, desc) => {
   }
   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.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  BaseService: () => BaseService,
-  ConnectorLoader: () => ConnectorLoader,
-  ErrorCodes: () => ErrorCodes,
-  Logger: () => Logger,
-  MockConnectorPlugin: () => MockConnectorPlugin,
-  OrdersService: () => OrdersService,
-  PluginManager: () => PluginManager,
-  ProductsService: () => ProductsService,
-  StallConnectorError: () => StallConnectorError,
-  StallCore: () => StallCore,
-  createErrorResponse: () => createErrorResponse,
-  createLogger: () => createLogger,
-  generateRequestId: () => generateRequestId,
-  handleConnectorError: () => handleConnectorError
+  categories: () => categories,
+  collections: () => collections,
+  customers: () => customers,
+  fulfillments: () => fulfillments,
+  initializeStallCore: () => initializeStallCore,
+  inventory_levels: () => inventory_levels,
+  locations: () => locations,
+  order_notes: () => order_notes,
+  orders: () => orders,
+  payment_providers: () => payment_providers,
+  payments: () => payments,
+  products: () => products,
+  promotions: () => promotions,
+  refunds: () => refunds,
+  tax_rates: () => tax_rates,
+  tax_regions: () => tax_regions,
+  variants: () => variants
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/utils/logger.ts
-var Logger = class {
-  level;
-  context;
-  constructor(context = "Stall", level = "info") {
-    this.context = context;
-    this.level = level;
-  }
-  shouldLog(level) {
-    const levels = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3
-    };
-    return levels[level] >= levels[this.level];
-  }
-  format(level, message, data) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const prefix = `[${timestamp}] [${this.context}] [${level.toUpperCase()}]`;
-    if (data) {
-      return `${prefix} ${message} ${JSON.stringify(data)}`;
+// src/db/db.ts
+var import_dexie = __toESM(require("dexie"));
+
+// src/db/schema.ts
+var schemas = {
+  connector_cache: "id",
+  products: "++id",
+  variants: "++id",
+  collections: "++id",
+  categories: "++id",
+  inventory_levels: "++id",
+  inventory_history: "++id",
+  promotions: "++id",
+  orders: "++id",
+  order_notes: "++id",
+  refunds: "++id",
+  payment_providers: "++id",
+  payments: "++id",
+  tax_regions: "++id",
+  tax_rates: "++id",
+  customers: "++id",
+  locations: "++id",
+  fulfillments: "++id"
+};
+
+// src/db/db.ts
+var options = { allowEmptyDB: true };
+var local_db = new import_dexie.default("stall-core-db", options);
+local_db.version(1).stores(schemas);
+
+// src/core/init.ts
+var initializeStallCore = (options2) => {
+  const sdk = {
+    options: options2,
+    adapter: async () => getAdapter(sdk),
+    refreshAdapter: async () => getAdapter(sdk, true)
+  };
+  void sdk.adapter();
+  return sdk;
+};
+var getAdapter = async (sdk, force) => {
+  const date = Date.now();
+  let module_code;
+  const cache_key = "connector-module";
+  const cached = await local_db.connector_cache.get(cache_key);
+  if (cached && !force) {
+    module_code = cached.code;
+  } else {
+    const response = await fetch(sdk.options.connector_url, {
+      mode: "cors",
+      method: "GET"
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch connector: ${response.statusText}`);
     }
-    return `${prefix} ${message}`;
+    module_code = await response.text();
+    await local_db.connector_cache.put({
+      id: cache_key,
+      code: module_code,
+      timestamp: date
+    });
   }
-  debug(message, data) {
-    if (this.shouldLog("debug")) {
-      console.debug(this.format("debug", message, data));
-    }
+  const blob = new Blob([module_code], { type: "application/javascript" });
+  const blobUrl = URL.createObjectURL(blob);
+  const module2 = await import(blobUrl);
+  URL.revokeObjectURL(blobUrl);
+  return module2;
+};
+
+// src/services/products.service.ts
+var list = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const products2 = await adapter.products.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return products2;
+  } catch (error) {
+    throw error;
   }
-  info(message, data) {
-    if (this.shouldLog("info")) {
-      console.info(this.format("info", message, data));
-    }
+};
+var retrieve = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const product = await adapter.products.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return product;
+  } catch (error) {
+    throw error;
   }
-  warn(message, data) {
-    if (this.shouldLog("warn")) {
-      console.warn(this.format("warn", message, data));
-    }
+};
+var create = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const product = await adapter.products.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return product;
+  } catch (error) {
+    throw error;
   }
-  error(message, error) {
-    if (this.shouldLog("error")) {
-      const data = error instanceof Error ? { message: error.message, stack: error.stack } : error;
-      console.error(this.format("error", message, data));
-    }
+};
+var update = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const product = await adapter.products.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return product;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.products.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const products2 = await adapter.products.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return products2;
+  } catch (error) {
+    throw error;
   }
-  setLevel(level) {
-    this.level = level;
+};
+var bulk_update = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const products2 = await adapter.products.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return products2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.products.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
   }
 };
-function createLogger(context = "Stall", level = "info") {
-  return new Logger(context, level);
-}
+var products = {
+  list,
+  retrieve,
+  create,
+  update,
+  delete: _delete,
+  bulk_create,
+  bulk_update,
+  bulk_delete
+};
 
-// src/utils/error-handler.ts
-var StallConnectorError = class extends Error {
-  code;
-  details;
-  statusCode;
-  constructor(message, code, statusCode, details) {
-    super(message);
-    this.name = "StallConnectorError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-  }
-};
-var ErrorCodes = {
-  // Initialization errors
-  INVALID_CONFIGURATION: "INVALID_CONFIGURATION",
-  MISSING_CREDENTIALS: "MISSING_CREDENTIALS",
-  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
-  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
-  PLUGIN_NOT_FOUND: "PLUGIN_NOT_FOUND",
-  // Operation errors
-  OPERATION_FAILED: "OPERATION_FAILED",
-  OPERATION_TIMEOUT: "OPERATION_TIMEOUT",
-  OPERATION_NOT_SUPPORTED: "OPERATION_NOT_SUPPORTED",
-  // Network errors
-  NETWORK_ERROR: "NETWORK_ERROR",
-  REQUEST_FAILED: "REQUEST_FAILED",
-  RATE_LIMITED: "RATE_LIMITED",
-  // Validation errors
-  VALIDATION_FAILED: "VALIDATION_FAILED",
-  INVALID_DATA: "INVALID_DATA",
-  MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD",
-  // Authentication errors
-  UNAUTHORIZED: "UNAUTHORIZED",
-  FORBIDDEN: "FORBIDDEN",
-  TOKEN_EXPIRED: "TOKEN_EXPIRED",
-  // Server errors
-  INTERNAL_ERROR: "INTERNAL_ERROR",
-  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE"
-};
-function handleConnectorError(error, context) {
-  if (error instanceof StallConnectorError) {
-    return error;
-  }
-  if (error?.response) {
-    const statusCode = error.response.status;
-    const data = error.response.data || error.response.body;
-    let code = ErrorCodes.REQUEST_FAILED;
-    if (statusCode === 401) code = ErrorCodes.UNAUTHORIZED;
-    else if (statusCode === 403) code = ErrorCodes.FORBIDDEN;
-    else if (statusCode === 429) code = ErrorCodes.RATE_LIMITED;
-    else if (statusCode >= 500) code = ErrorCodes.INTERNAL_ERROR;
-    return new StallConnectorError(
-      `${context}: ${data?.message || error.message}`,
-      code,
-      statusCode,
+// src/services/orders.service.ts
+var list2 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const orders2 = await adapter.orders.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return orders2;
+  } catch (error) {
+    throw new Error(
+      `Failed to list orders: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
+var retrieve2 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const order = await adapter.orders.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return order;
+  } catch (error) {
+    throw new Error(
+      `Failed to retrieve order: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
+var create2 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const order = await adapter.orders.create({
+      connector_config: sdk.options.configuration,
       data
+    });
+    return order;
+  } catch (error) {
+    throw new Error(
+      `Failed to create order: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  if (error?.code === "ECONNABORTED" || error?.message?.includes("timeout")) {
-    return new StallConnectorError(
-      `${context}: Operation timed out`,
-      ErrorCodes.OPERATION_TIMEOUT
+};
+var update2 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const order = await adapter.orders.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return order;
+  } catch (error) {
+    throw new Error(
+      `Failed to update order: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  if (error?.code === "ECONNREFUSED" || error?.code === "ENOTFOUND" || error?.message?.includes("network")) {
-    return new StallConnectorError(
-      `${context}: Network error - ${error.message}`,
-      ErrorCodes.NETWORK_ERROR
+};
+var _delete2 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.orders.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw new Error(
+      `Failed to delete order: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  if (error?.name === "ValidationError") {
-    return new StallConnectorError(
-      `${context}: Validation failed - ${error.message}`,
-      ErrorCodes.VALIDATION_FAILED,
-      400,
-      error.details
+};
+var bulk_create2 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const orders2 = await adapter.orders.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return orders2;
+  } catch (error) {
+    throw new Error(
+      `Failed to bulk create orders: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  return new StallConnectorError(
-    `${context}: ${error.message || "Unknown error"}`,
-    ErrorCodes.OPERATION_FAILED,
-    void 0,
-    error
-  );
-}
-function createErrorResponse(error, operation, connectorId) {
-  const isStallError = error instanceof StallConnectorError;
-  return {
-    success: false,
-    error: {
-      code: isStallError ? error.code : ErrorCodes.OPERATION_FAILED,
-      message: error.message,
-      details: isStallError ? error.details : void 0
-    },
-    metadata: {
-      connector_id: connectorId,
-      operation,
-      timestamp: Date.now(),
-      request_id: generateRequestId()
-    }
-  };
-}
-function generateRequestId() {
-  return `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
+};
+var bulk_update2 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const orders2 = await adapter.orders.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return orders2;
+  } catch (error) {
+    throw new Error(
+      `Failed to bulk update orders: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
+var bulk_delete2 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.orders.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw new Error(
+      `Failed to bulk delete orders: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
+var orders = {
+  list: list2,
+  retrieve: retrieve2,
+  create: create2,
+  update: update2,
+  delete: _delete2,
+  bulk_create: bulk_create2,
+  bulk_update: bulk_update2,
+  bulk_delete: bulk_delete2
+};
 
-// src/core/connector-loader.ts
-var ConnectorLoader = class {
-  logger;
-  connectorUrl;
-  cache = /* @__PURE__ */ new Map();
-  cacheTtl;
-  constructor(options) {
-    this.logger = new Logger("ConnectorLoader");
-    this.connectorUrl = options.connectorUrl;
-    this.cacheTtl = options.cacheTtl || 60 * 60 * 1e3;
-  }
-  /**
-   * Load a connector plugin from public URL
-   * URL pattern: {connectorUrl}/{integrationId}/index.js
-   */
-  async loadConnector(integrationId) {
-    const cacheKey = integrationId;
-    if (this.cache.has(cacheKey)) {
-      this.logger.debug(`Loaded ${integrationId} from cache`);
-      return this.cache.get(cacheKey);
-    }
-    try {
-      this.logger.info(`Loading connector plugin: ${integrationId}`);
-      const url = this.buildConnectorUrl(integrationId);
-      this.logger.debug(`Fetching from: ${url}`);
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch connector: ${response.statusText} (${response.status})`
-        );
-      }
-      const code = await response.text();
-      const plugin = await this.instantiatePlugin(code, integrationId);
-      this.logger.info(`Successfully loaded ${integrationId}`);
-      this.cache.set(cacheKey, plugin);
-      return plugin;
-    } catch (error) {
-      this.logger.error(
-        `Failed to load connector ${integrationId}`,
-        error
-      );
-      throw new StallConnectorError(
-        `Failed to load connector plugin: ${integrationId}`,
-        ErrorCodes.PLUGIN_LOAD_FAILED,
-        void 0,
-        { originalError: error.message }
-      );
-    }
+// src/services/customers.service.ts
+var list3 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const customers2 = await adapter.customers.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return customers2;
+  } catch (error) {
+    throw error;
   }
-  /**
-   * Instantiate a plugin from code
-   */
-  async instantiatePlugin(code, integrationId) {
-    try {
-      const moduleExports = {};
-      const module2 = { exports: moduleExports };
-      const fn = new Function(
-        "module",
-        "exports",
-        "require",
-        code + "\nreturn module.exports;"
-      );
-      const pluginModule = fn(
-        module2,
-        moduleExports,
-        this.createRequireProxy()
-      );
-      const PluginClass = pluginModule.default || pluginModule.Plugin;
-      if (!PluginClass) {
-        throw new Error("Plugin module does not export a default or Plugin");
-      }
-      const instance = new PluginClass();
-      if (!this.validatePlugin(instance)) {
-        throw new Error("Plugin does not implement IConnectorPlugin interface");
-      }
-      return instance;
-    } catch (error) {
-      throw new StallConnectorError(
-        `Failed to instantiate plugin: ${integrationId}`,
-        ErrorCodes.PLUGIN_LOAD_FAILED,
-        void 0,
-        { originalError: error.message }
-      );
-    }
+};
+var retrieve3 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const customer = await adapter.customers.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return customer;
+  } catch (error) {
+    throw error;
   }
-  /**
-   * Validate that an object implements IConnectorPlugin
-   */
-  validatePlugin(plugin) {
-    const requiredMethods = ["initialize", "verify", "getSupportedModules"];
-    const requiredModules = ["orders", "products", "customers", "inventory"];
-    for (const method of requiredMethods) {
-      if (typeof plugin[method] !== "function") {
-        this.logger.warn(`Plugin missing method: ${method}`);
-      }
-    }
-    for (const module2 of requiredModules) {
-      if (typeof plugin[module2] !== "object") {
-        this.logger.warn(`Plugin missing module: ${module2}`);
-      }
-    }
-    return true;
-  }
-  /**
-   * Build the connector plugin URL
-   * Pattern: {connectorUrl}/{integrationId}/index.js
-   */
-  buildConnectorUrl(integrationId) {
-    const baseUrl = this.connectorUrl.endsWith("/") ? this.connectorUrl.slice(0, -1) : this.connectorUrl;
-    return `${baseUrl}/${integrationId}/index.js`;
-  }
-  /**
-   * Create a proxy for require() in loaded plugins
-   */
-  createRequireProxy() {
-    return (id) => {
-      if (id === "@use-stall/types") {
-        return require("@use-stall/types");
-      }
-      if (id === "node:crypto" || id === "crypto") {
-        return require("crypto");
-      }
-      this.logger.warn(`Attempted to require unsupported module: ${id}`);
-      return {};
-    };
-  }
-  /**
-   * Clear the cache
-   */
-  clearCache() {
-    this.cache.clear();
-    this.logger.info("Plugin cache cleared");
-  }
-  /**
-   * Remove a specific plugin from cache
-   */
-  removeCacheEntry(integrationId) {
-    this.cache.delete(integrationId);
-    this.logger.info(`Removed ${integrationId} from cache`);
+};
+var create3 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const customer = await adapter.customers.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return customer;
+  } catch (error) {
+    throw error;
+  }
+};
+var update3 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const customer = await adapter.customers.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return customer;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete3 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.customers.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create3 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const customers2 = await adapter.customers.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return customers2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update3 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const customers2 = await adapter.customers.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return customers2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete3 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.customers.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
   }
 };
+var customers = {
+  list: list3,
+  retrieve: retrieve3,
+  create: create3,
+  update: update3,
+  delete: _delete3,
+  bulk_create: bulk_create3,
+  bulk_update: bulk_update3,
+  bulk_delete: bulk_delete3
+};
 
-// src/core/plugin-manager.ts
-var PluginManager = class {
-  plugin = null;
-  logger;
-  connectorLoader = null;
-  initialized = false;
-  constructor(logLevel = "info") {
-    this.logger = new Logger("PluginManager", logLevel);
-  }
-  /**
-   * Initialize the plugin manager with a plugin
-   */
-  async initialize(plugin, options) {
-    try {
-      if (!plugin) {
-        const connectorUrl = options.options?.connectorUrl || "https://connectors.myapp.xyz";
-        this.connectorLoader = new ConnectorLoader({
-          connectorUrl,
-          cache: options.options?.cachePlugins !== false
-        });
-        plugin = await this.connectorLoader.loadConnector(
-          options.integration_id
-        );
-      }
-      if (!plugin) {
-        throw new StallConnectorError(
-          "Failed to load connector plugin",
-          ErrorCodes.PLUGIN_NOT_FOUND
-        );
-      }
-      this.plugin = plugin;
-      const pluginConfig = {
-        connectorId: options.id,
-        integrationId: options.integration_id,
-        organizationId: options.id,
-        // Use the config id as org context
-        configuration: options.configuration,
-        options: options.options
-      };
-      await this.plugin.initialize(pluginConfig);
-      this.logger.info(
-        `Plugin initialized: ${this.plugin.metadata.name}@${this.plugin.metadata.version}`
-      );
-      this.initialized = true;
-    } catch (error) {
-      this.logger.error("Failed to initialize plugin manager", error);
-      throw error;
-    }
+// src/services/collections.service.ts
+var list4 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const collections2 = await adapter.collections.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return collections2;
+  } catch (error) {
+    throw error;
   }
-  /**
-   * Get the loaded plugin
-   */
-  getPlugin() {
-    if (!this.plugin) {
-      throw new StallConnectorError(
-        "Plugin not initialized",
-        ErrorCodes.INVALID_CONFIGURATION
-      );
-    }
-    return this.plugin;
-  }
-  /**
-   * Check if plugin is initialized
-   */
-  isInitialized() {
-    return this.initialized && this.plugin !== null;
-  }
-  /**
-   * Verify the plugin configuration
-   */
-  async verify() {
-    if (!this.isInitialized()) {
-      throw new StallConnectorError(
-        "Plugin not initialized",
-        ErrorCodes.INVALID_CONFIGURATION
-      );
-    }
-    const result = await this.plugin.verify();
-    return result.success && result.data === true;
-  }
-  /**
-   * Get metadata about the loaded plugin
-   */
-  getMetadata() {
-    if (!this.plugin) {
-      throw new StallConnectorError(
-        "Plugin not initialized",
-        ErrorCodes.INVALID_CONFIGURATION
-      );
-    }
-    return {
-      id: this.plugin.metadata.id,
-      name: this.plugin.metadata.name,
-      version: this.plugin.metadata.version,
-      description: this.plugin.metadata.description,
-      supportedModules: this.plugin.getSupportedModules()
-    };
-  }
-  /**
-   * Check if a module is supported
-   */
-  isModuleSupported(module2) {
-    if (!this.plugin) return false;
-    return this.plugin.getSupportedModules().includes(module2);
-  }
-  /**
-   * Clear plugin cache (if using remote loading)
-   */
-  clearCache() {
-    if (this.connectorLoader) {
-      this.connectorLoader.clearCache();
-      this.logger.info("Plugin cache cleared");
-    }
+};
+var retrieve4 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const collection = await adapter.collections.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return collection;
+  } catch (error) {
+    throw error;
   }
 };
+var create4 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const collection = await adapter.collections.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return collection;
+  } catch (error) {
+    throw error;
+  }
+};
+var update4 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const collection = await adapter.collections.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return collection;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete4 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.collections.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create4 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const collections2 = await adapter.collections.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return collections2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update4 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const collections2 = await adapter.collections.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return collections2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete4 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.collections.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var collections = {
+  list: list4,
+  retrieve: retrieve4,
+  create: create4,
+  update: update4,
+  delete: _delete4,
+  bulk_create: bulk_create4,
+  bulk_update: bulk_update4,
+  bulk_delete: bulk_delete4
+};
 
-// src/services/base.service.ts
-var BaseService = class {
-  logger;
-  pluginManager;
-  connectorId;
-  constructor(pluginManager, connectorId, serviceName) {
-    this.pluginManager = pluginManager;
-    this.connectorId = connectorId;
-    this.logger = new Logger(serviceName);
-  }
-  /**
-   * Wrap a connector operation with error handling and logging
-   */
-  async executeOperation(operation, fn) {
-    const requestId = generateRequestId();
-    const startTime = Date.now();
-    try {
-      this.logger.debug(`[${requestId}] Starting operation: ${operation}`);
-      const result = await fn();
-      const duration = Date.now() - startTime;
-      this.logger.info(
-        `[${requestId}] Operation completed: ${operation} (${duration}ms)`,
-        { success: result.success }
-      );
-      return {
-        ...result,
-        metadata: {
-          ...result.metadata,
-          connector_id: this.connectorId,
-          operation,
-          timestamp: Date.now(),
-          request_id: requestId
-        }
-      };
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      this.logger.error(
-        `[${requestId}] Operation failed: ${operation} (${duration}ms)`,
-        error
-      );
-      return createErrorResponse(
-        error,
-        operation,
-        this.connectorId
-      );
-    }
+// src/services/categories.service.ts
+var list5 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const categories2 = await adapter.categories.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return categories2;
+  } catch (error) {
+    throw error;
   }
-  /**
-   * Check if a module is supported
-   */
-  isModuleSupported(module2) {
-    return this.pluginManager.isModuleSupported(module2);
-  }
-  /**
-   * Get the plugin instance
-   */
-  getPlugin() {
-    return this.pluginManager.getPlugin();
-  }
-  /**
-   * Verify plugin is ready
-   */
-  ensurePluginInitialized() {
-    if (!this.pluginManager.isInitialized()) {
-      throw new StallConnectorError(
-        "Plugin not initialized",
-        ErrorCodes.INVALID_CONFIGURATION
-      );
-    }
+};
+var retrieve5 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const category = await adapter.categories.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return category;
+  } catch (error) {
+    throw error;
+  }
+};
+var create5 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const category = await adapter.categories.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return category;
+  } catch (error) {
+    throw error;
+  }
+};
+var update5 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const category = await adapter.categories.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return category;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete5 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.categories.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create5 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const categories2 = await adapter.categories.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return categories2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update5 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const categories2 = await adapter.categories.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return categories2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete5 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.categories.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
   }
 };
+var categories = {
+  list: list5,
+  retrieve: retrieve5,
+  create: create5,
+  update: update5,
+  delete: _delete5,
+  bulk_create: bulk_create5,
+  bulk_update: bulk_update5,
+  bulk_delete: bulk_delete5
+};
 
-// src/services/orders.service.ts
-var OrdersService = class extends BaseService {
-  constructor(pluginManager, connectorId) {
-    super(pluginManager, connectorId, "OrdersService");
-  }
-  /**
-   * Create a new order
-   */
-  async createOrder(order) {
-    return this.executeOperation("orders.create", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("orders")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Orders module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.orders.create(order);
-    });
-  }
-  /**
-   * Get an order by ID
-   */
-  async getOrder(orderId) {
-    return this.executeOperation("orders.get", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("orders")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Orders module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.orders.get(orderId);
-    });
-  }
-  /**
-   * Update an existing order
-   */
-  async updateOrder(orderId, order) {
-    return this.executeOperation("orders.update", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("orders")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Orders module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.orders.update(orderId, order);
-    });
-  }
-  /**
-   * Delete/cancel an order
-   */
-  async deleteOrder(orderId) {
-    return this.executeOperation("orders.delete", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("orders")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Orders module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.orders.delete(orderId);
-    });
-  }
-  /**
-   * List orders with optional filtering
-   */
-  async listOrders(options) {
-    return this.executeOperation("orders.list", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("orders")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Orders module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.orders.list(options);
-    });
-  }
-  /**
-   * Create a refund for an order
-   */
-  async createRefund(orderId, refund) {
-    return this.executeOperation("refunds.create", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("orders")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Orders module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.refunds.create(orderId, refund);
-    });
-  }
-  /**
-   * Get a refund by ID
-   */
-  async getRefund(refundId) {
-    return this.executeOperation("refunds.get", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("orders")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Orders module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.refunds.get(refundId);
-    });
-  }
-  /**
-   * List refunds for an order
-   */
-  async listRefunds(orderId, options) {
-    return this.executeOperation("refunds.list", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("orders")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Orders module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.refunds.list(orderId, options);
+// src/services/variants.service.ts
+var list6 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const variants2 = await adapter.variants.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return variants2;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve6 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const variant = await adapter.variants.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return variant;
+  } catch (error) {
+    throw error;
+  }
+};
+var create6 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const variant = await adapter.variants.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return variant;
+  } catch (error) {
+    throw error;
+  }
+};
+var update6 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const variant = await adapter.variants.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
     });
+    return variant;
+  } catch (error) {
+    throw error;
   }
 };
+var _delete6 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.variants.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create6 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const variants2 = await adapter.variants.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return variants2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update6 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const variants2 = await adapter.variants.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return variants2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete6 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.variants.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var variants = {
+  list: list6,
+  retrieve: retrieve6,
+  create: create6,
+  update: update6,
+  delete: _delete6,
+  bulk_create: bulk_create6,
+  bulk_update: bulk_update6,
+  bulk_delete: bulk_delete6
+};
 
-// src/services/products.service.ts
-var ProductsService = class extends BaseService {
-  constructor(pluginManager, connectorId) {
-    super(pluginManager, connectorId, "ProductsService");
-  }
-  /**
-   * Create a new product
-   */
-  async createProduct(product) {
-    return this.executeOperation("products.create", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("products")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Products module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.products.create(product);
-    });
-  }
-  /**
-   * Get a product by ID
-   */
-  async getProduct(productId) {
-    return this.executeOperation("products.get", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("products")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Products module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.products.get(productId);
-    });
-  }
-  /**
-   * Update an existing product
-   */
-  async updateProduct(productId, product) {
-    return this.executeOperation("products.update", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("products")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Products module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.products.update(productId, product);
-    });
-  }
-  /**
-   * Delete a product
-   */
-  async deleteProduct(productId) {
-    return this.executeOperation("products.delete", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("products")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Products module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.products.delete(productId);
-    });
-  }
-  /**
-   * List products with optional filtering
-   */
-  async listProducts(options) {
-    return this.executeOperation("products.list", async () => {
-      this.ensurePluginInitialized();
-      if (!this.isModuleSupported("products")) {
-        return {
-          success: false,
-          error: {
-            code: "MODULE_NOT_SUPPORTED",
-            message: "Products module is not supported by this connector"
-          }
-        };
-      }
-      const plugin = this.getPlugin();
-      return plugin.products.list(options);
+// src/services/inventory-levels.service.ts
+var list7 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const inventories = await adapter.inventory_levels.list({
+      connector_config: sdk.options.configuration,
+      query
     });
+    return inventories;
+  } catch (error) {
+    throw error;
   }
 };
+var retrieve7 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const inventory = await adapter.inventory_levels.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return inventory;
+  } catch (error) {
+    throw error;
+  }
+};
+var create7 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const inventory = await adapter.inventory_levels.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return inventory;
+  } catch (error) {
+    throw error;
+  }
+};
+var update7 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const inventory = await adapter.inventory_levels.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return inventory;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete7 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.inventory_levels.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create7 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const inventories = await adapter.inventory_levels.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return inventories;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update7 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const inventories = await adapter.inventory_levels.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return inventories;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete7 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.inventory_levels.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var inventory_levels = {
+  list: list7,
+  retrieve: retrieve7,
+  create: create7,
+  update: update7,
+  delete: _delete7,
+  bulk_create: bulk_create7,
+  bulk_update: bulk_update7,
+  bulk_delete: bulk_delete7
+};
 
-// src/core/sdk.ts
-var StallCore = class _StallCore {
-  pluginManager;
-  logger;
-  options;
-  // Service instances
-  orders;
-  products;
-  constructor(options) {
-    this.options = options;
-    const logLevel = options.options?.logLevel || "info";
-    this.logger = new Logger("StallSDK", logLevel);
-    this.pluginManager = new PluginManager(logLevel);
-    this.orders = new OrdersService(this.pluginManager, options.id);
-    this.products = new ProductsService(this.pluginManager, options.id);
-  }
-  /**
-   * Firebase-style initialization with automatic plugin loading
-   * Loads connector from public URL: {connectorUrl}/{integration_id}/index.js
-   * Default URL: https://connectors.myapp.xyz
-   */
-  static async initialize(options) {
-    const sdk = new _StallCore(options);
-    try {
-      await sdk.pluginManager.initialize(null, options);
-      sdk.logger.info("StallSDK initialized successfully");
-    } catch (error) {
-      sdk.logger.error("Failed to initialize StallSDK", error);
-      throw error;
-    }
-    return sdk;
-  }
-  /**
-   * Initialize with a provided plugin instance (for testing/custom plugins)
-   * Useful for mock plugins or custom implementations
-   */
-  static async initializeWithPlugin(options, plugin) {
-    const sdk = new _StallCore(options);
-    try {
-      await sdk.pluginManager.initialize(plugin, options);
-      sdk.logger.info("StallSDK initialized with custom plugin");
-    } catch (error) {
-      sdk.logger.error("Failed to initialize StallSDK", error);
-      throw error;
-    }
-    return sdk;
-  }
-  /**
-   * Get plugin metadata
-   */
-  getMetadata() {
-    return this.pluginManager.getMetadata();
-  }
-  /**
-   * Verify the connector configuration
-   */
-  async verify() {
-    return this.pluginManager.verify();
-  }
-  /**
-   * Check if a module is supported
-   */
-  isModuleSupported(module2) {
-    return this.pluginManager.isModuleSupported(module2);
-  }
-  /**
-   * Check if SDK is initialized
-   */
-  isInitialized() {
-    return this.pluginManager.isInitialized();
-  }
-  /**
-   * Clear plugin cache
-   */
-  clearCache() {
-    this.pluginManager.clearCache();
-  }
-  /**
-   * Get the underlying plugin instance
-   */
-  getPlugin() {
-    return this.pluginManager.getPlugin();
-  }
-  /**
-   * Get SDK configuration
-   */
-  getConfiguration() {
-    return {
-      id: this.options.id,
-      integration_id: this.options.integration_id,
-      created_at: this.options.created_at,
-      updated_at: this.options.updated_at
-    };
+// src/services/promotions.service.ts
+var list8 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const promotions2 = await adapter.promotions.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return promotions2;
+  } catch (error) {
+    throw error;
   }
 };
+var retrieve8 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const promotion = await adapter.promotions.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return promotion;
+  } catch (error) {
+    throw error;
+  }
+};
+var create8 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const promotion = await adapter.promotions.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return promotion;
+  } catch (error) {
+    throw error;
+  }
+};
+var update8 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const promotion = await adapter.promotions.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return promotion;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete8 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.promotions.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create8 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const promotions2 = await adapter.promotions.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return promotions2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update8 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const promotions2 = await adapter.promotions.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return promotions2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete8 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.promotions.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var promotions = {
+  list: list8,
+  retrieve: retrieve8,
+  create: create8,
+  update: update8,
+  delete: _delete8,
+  bulk_create: bulk_create8,
+  bulk_update: bulk_update8,
+  bulk_delete: bulk_delete8
+};
 
-// src/plugins/mock-connector.plugin.ts
-var MockConnectorPlugin = class {
-  metadata = {
-    id: "mock",
-    name: "Mock Connector",
-    version: "1.0.0",
-    description: "Mock connector for development and testing purposes"
-  };
-  config = null;
-  initialized = false;
-  async initialize(config) {
-    this.config = config;
-    this.initialized = true;
-    console.log(`Mock connector initialized for: ${config.integrationId}`);
-  }
-  async verify() {
-    if (!this.initialized) {
-      return {
-        success: false,
-        error: {
-          code: "NOT_INITIALIZED",
-          message: "Plugin not initialized"
-        }
-      };
-    }
-    return {
-      success: true,
-      data: true,
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "verify",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    };
-  }
-  getSupportedModules() {
-    return ["orders", "products", "customers", "inventory", "refunds", "payments"];
-  }
-  orders = {
-    create: async (order) => ({
-      success: true,
-      data: {
-        ...order,
-        id: `mock_order_${Date.now()}`,
-        created_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "orders.create",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    get: async (orderId) => ({
-      success: true,
-      data: {
-        id: orderId,
-        order_number: `ORD-${orderId}`,
-        status: "completed",
-        total: 100
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "orders.get",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    update: async (orderId, order) => ({
-      success: true,
-      data: {
-        id: orderId,
-        ...order,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "orders.update",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    delete: async (orderId) => ({
-      success: true,
-      data: null,
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "orders.delete",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    list: async (options) => {
-      const limit = options?.limit || 10;
-      const orders = Array.from({ length: limit }, (_, i) => ({
-        id: `mock_order_${i}`,
-        order_number: `ORD-${i}`,
-        status: "completed",
-        total: (i + 1) * 100
-      }));
-      return {
-        success: true,
-        data: orders,
-        metadata: {
-          connector_id: this.config?.connectorId || "mock",
-          operation: "orders.list",
-          timestamp: Date.now(),
-          request_id: `req_${Date.now()}`
-        }
-      };
-    }
-  };
-  products = {
-    create: async (product) => ({
-      success: true,
-      data: {
-        ...product,
-        id: `mock_product_${Date.now()}`,
-        created_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "products.create",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    get: async (productId) => ({
-      success: true,
-      data: {
-        id: productId,
-        title: "Mock Product",
-        price: 99.99,
-        sku: `MOCK-${productId}`
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "products.get",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    update: async (productId, product) => ({
-      success: true,
-      data: {
-        id: productId,
-        ...product,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "products.update",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    delete: async (productId) => ({
-      success: true,
-      data: null,
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "products.delete",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    list: async (options) => {
-      const limit = options?.limit || 10;
-      const products = Array.from({ length: limit }, (_, i) => ({
-        id: `mock_product_${i}`,
-        title: `Mock Product ${i}`,
-        price: (i + 1) * 10,
-        sku: `MOCK-${i}`
-      }));
-      return {
-        success: true,
-        data: products,
-        metadata: {
-          connector_id: this.config?.connectorId || "mock",
-          operation: "products.list",
-          timestamp: Date.now(),
-          request_id: `req_${Date.now()}`
-        }
-      };
-    }
-  };
-  customers = {
-    create: async (customer) => ({
-      success: true,
-      data: {
-        ...customer,
-        id: `mock_customer_${Date.now()}`,
-        created_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "customers.create",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    get: async (customerId) => ({
-      success: true,
-      data: {
-        id: customerId,
-        email: "customer@example.com",
-        name: "Mock Customer"
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "customers.get",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    update: async (customerId, customer) => ({
-      success: true,
-      data: {
-        id: customerId,
-        ...customer,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "customers.update",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    delete: async (customerId) => ({
-      success: true,
-      data: null,
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "customers.delete",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    list: async (options) => {
-      const limit = options?.limit || 10;
-      const customers = Array.from({ length: limit }, (_, i) => ({
-        id: `mock_customer_${i}`,
-        email: `customer${i}@example.com`,
-        name: `Customer ${i}`
-      }));
-      return {
-        success: true,
-        data: customers,
-        metadata: {
-          connector_id: this.config?.connectorId || "mock",
-          operation: "customers.list",
-          timestamp: Date.now(),
-          request_id: `req_${Date.now()}`
-        }
-      };
-    }
-  };
-  inventory = {
-    get: async (productId, variantId) => ({
-      success: true,
-      data: {
-        product_id: productId,
-        variant_id: variantId,
-        in_stock: 100,
-        committed: 0,
-        on_hand: 100
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "inventory.get",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    update: async (productId, inventory, variantId) => ({
-      success: true,
-      data: {
-        product_id: productId,
-        variant_id: variantId,
-        ...inventory,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "inventory.update",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    list: async (options) => {
-      const limit = options?.limit || 10;
-      const inventoryItems = Array.from({ length: limit }, (_, i) => ({
-        product_id: `mock_product_${i}`,
-        in_stock: (i + 1) * 10,
-        committed: 0,
-        on_hand: (i + 1) * 10
-      }));
-      return {
-        success: true,
-        data: inventoryItems,
-        metadata: {
-          connector_id: this.config?.connectorId || "mock",
-          operation: "inventory.list",
-          timestamp: Date.now(),
-          request_id: `req_${Date.now()}`
-        }
-      };
-    }
-  };
-  refunds = {
-    create: async (orderId, refund) => ({
-      success: true,
-      data: {
-        ...refund,
-        id: `mock_refund_${Date.now()}`,
-        order_id: orderId,
-        created_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "refunds.create",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    get: async (refundId) => ({
-      success: true,
-      data: {
-        id: refundId,
-        amount: 100,
-        reason: "Customer request",
-        status: "completed"
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "refunds.get",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    list: async (orderId, options) => {
-      const limit = options?.limit || 10;
-      const refunds = Array.from({ length: limit }, (_, i) => ({
-        id: `mock_refund_${i}`,
-        order_id: orderId,
-        amount: (i + 1) * 10,
-        reason: "Customer request",
-        status: "completed"
-      }));
-      return {
-        success: true,
-        data: refunds,
-        metadata: {
-          connector_id: this.config?.connectorId || "mock",
-          operation: "refunds.list",
-          timestamp: Date.now(),
-          request_id: `req_${Date.now()}`
-        }
-      };
-    }
-  };
-  payments = {
-    create: async (payment) => ({
-      success: true,
-      data: {
-        ...payment,
-        id: `mock_payment_${Date.now()}`,
-        status: "successful",
-        created_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "payments.create",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    get: async (paymentId) => ({
-      success: true,
-      data: {
-        id: paymentId,
-        amount: 100,
-        status: "successful",
-        method: "card"
-      },
-      metadata: {
-        connector_id: this.config?.connectorId || "mock",
-        operation: "payments.get",
-        timestamp: Date.now(),
-        request_id: `req_${Date.now()}`
-      }
-    }),
-    list: async (options) => {
-      const limit = options?.limit || 10;
-      const payments = Array.from({ length: limit }, (_, i) => ({
-        id: `mock_payment_${i}`,
-        amount: (i + 1) * 100,
-        status: "successful",
-        method: "card"
-      }));
-      return {
-        success: true,
-        data: payments,
-        metadata: {
-          connector_id: this.config?.connectorId || "mock",
-          operation: "payments.list",
-          timestamp: Date.now(),
-          request_id: `req_${Date.now()}`
-        }
-      };
-    }
-  };
+// src/services/order-notes.service.ts
+var list9 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const notes = await adapter.order_notes.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return notes;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve9 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const note = await adapter.order_notes.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return note;
+  } catch (error) {
+    throw error;
+  }
+};
+var create9 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const note = await adapter.order_notes.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return note;
+  } catch (error) {
+    throw error;
+  }
+};
+var update9 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const note = await adapter.order_notes.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return note;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete9 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.order_notes.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create9 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const notes = await adapter.order_notes.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return notes;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update9 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const notes = await adapter.order_notes.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return notes;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete9 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.order_notes.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var order_notes = {
+  list: list9,
+  retrieve: retrieve9,
+  create: create9,
+  update: update9,
+  delete: _delete9,
+  bulk_create: bulk_create9,
+  bulk_update: bulk_update9,
+  bulk_delete: bulk_delete9
+};
+
+// src/services/refunds.service.ts
+var list10 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const refunds2 = await adapter.refunds.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return refunds2;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve10 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const refund = await adapter.refunds.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return refund;
+  } catch (error) {
+    throw error;
+  }
+};
+var create10 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const refund = await adapter.refunds.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return refund;
+  } catch (error) {
+    throw error;
+  }
+};
+var update10 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const refund = await adapter.refunds.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return refund;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete10 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.refunds.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create10 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const refunds2 = await adapter.refunds.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return refunds2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update10 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const refunds2 = await adapter.refunds.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return refunds2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete10 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.refunds.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var refunds = {
+  list: list10,
+  retrieve: retrieve10,
+  create: create10,
+  update: update10,
+  delete: _delete10,
+  bulk_create: bulk_create10,
+  bulk_update: bulk_update10,
+  bulk_delete: bulk_delete10
+};
+
+// src/services/payment-providers.service.ts
+var list11 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const providers = await adapter.payment_providers.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return providers;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve11 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const provider = await adapter.payment_providers.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return provider;
+  } catch (error) {
+    throw error;
+  }
+};
+var create11 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const provider = await adapter.payment_providers.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return provider;
+  } catch (error) {
+    throw error;
+  }
+};
+var update11 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const provider = await adapter.payment_providers.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return provider;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete11 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.payment_providers.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create11 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const providers = await adapter.payment_providers.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return providers;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update11 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const providers = await adapter.payment_providers.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return providers;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete11 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.payment_providers.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var payment_providers = {
+  list: list11,
+  retrieve: retrieve11,
+  create: create11,
+  update: update11,
+  delete: _delete11,
+  bulk_create: bulk_create11,
+  bulk_update: bulk_update11,
+  bulk_delete: bulk_delete11
+};
+
+// src/services/payments.service.ts
+var list12 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const payments2 = await adapter.payments.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return payments2;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve12 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const payment = await adapter.payments.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return payment;
+  } catch (error) {
+    throw error;
+  }
+};
+var create12 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const payment = await adapter.payments.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return payment;
+  } catch (error) {
+    throw error;
+  }
+};
+var update12 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const payment = await adapter.payments.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return payment;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete12 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.payments.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create12 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const payments2 = await adapter.payments.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return payments2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update12 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const payments2 = await adapter.payments.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return payments2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete12 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.payments.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var payments = {
+  list: list12,
+  retrieve: retrieve12,
+  create: create12,
+  update: update12,
+  delete: _delete12,
+  bulk_create: bulk_create12,
+  bulk_update: bulk_update12,
+  bulk_delete: bulk_delete12
+};
+
+// src/services/tax-regions.service.ts
+var list13 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const regions = await adapter.tax_regions.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return regions;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve13 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const region = await adapter.tax_regions.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return region;
+  } catch (error) {
+    throw error;
+  }
+};
+var create13 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const region = await adapter.tax_regions.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return region;
+  } catch (error) {
+    throw error;
+  }
+};
+var update13 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const region = await adapter.tax_regions.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return region;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete13 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.tax_regions.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create13 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const regions = await adapter.tax_regions.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return regions;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update13 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const regions = await adapter.tax_regions.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return regions;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete13 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.tax_regions.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var tax_regions = {
+  list: list13,
+  retrieve: retrieve13,
+  create: create13,
+  update: update13,
+  delete: _delete13,
+  bulk_create: bulk_create13,
+  bulk_update: bulk_update13,
+  bulk_delete: bulk_delete13
+};
+
+// src/services/tax-rates.service.ts
+var list14 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const rates = await adapter.tax_rates.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return rates;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve14 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const rate = await adapter.tax_rates.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return rate;
+  } catch (error) {
+    throw error;
+  }
+};
+var create14 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const rate = await adapter.tax_rates.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return rate;
+  } catch (error) {
+    throw error;
+  }
+};
+var update14 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const rate = await adapter.tax_rates.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return rate;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete14 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.tax_rates.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create14 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const rates = await adapter.tax_rates.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return rates;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update14 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const rates = await adapter.tax_rates.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return rates;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete14 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.tax_rates.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var tax_rates = {
+  list: list14,
+  retrieve: retrieve14,
+  create: create14,
+  update: update14,
+  delete: _delete14,
+  bulk_create: bulk_create14,
+  bulk_update: bulk_update14,
+  bulk_delete: bulk_delete14
+};
+
+// src/services/locations.service.ts
+var list15 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const locations2 = await adapter.locations.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return locations2;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve15 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const location = await adapter.locations.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return location;
+  } catch (error) {
+    throw error;
+  }
+};
+var create15 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const location = await adapter.locations.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return location;
+  } catch (error) {
+    throw error;
+  }
+};
+var update15 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const location = await adapter.locations.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return location;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete15 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.locations.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create15 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const locations2 = await adapter.locations.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return locations2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update15 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const locations2 = await adapter.locations.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return locations2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete15 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.locations.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var locations = {
+  list: list15,
+  retrieve: retrieve15,
+  create: create15,
+  update: update15,
+  delete: _delete15,
+  bulk_create: bulk_create15,
+  bulk_update: bulk_update15,
+  bulk_delete: bulk_delete15
+};
+
+// src/services/fulfillments.service.ts
+var list16 = async (props) => {
+  try {
+    const { sdk, query } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const fulfillments2 = await adapter.fulfillments.list({
+      connector_config: sdk.options.configuration,
+      query
+    });
+    return fulfillments2;
+  } catch (error) {
+    throw error;
+  }
+};
+var retrieve16 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const fulfillment = await adapter.fulfillments.retrieve({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return fulfillment;
+  } catch (error) {
+    throw error;
+  }
+};
+var create16 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const fulfillment = await adapter.fulfillments.create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return fulfillment;
+  } catch (error) {
+    throw error;
+  }
+};
+var update16 = async (props) => {
+  try {
+    const { sdk, id, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const fulfillment = await adapter.fulfillments.update({
+      connector_config: sdk.options.configuration,
+      id,
+      data
+    });
+    return fulfillment;
+  } catch (error) {
+    throw error;
+  }
+};
+var _delete16 = async (props) => {
+  try {
+    const { sdk, id } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.fulfillments.delete({
+      connector_config: sdk.options.configuration,
+      id
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_create16 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const fulfillments2 = await adapter.fulfillments.bulk_create({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return fulfillments2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_update16 = async (props) => {
+  try {
+    const { sdk, data } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    const fulfillments2 = await adapter.fulfillments.bulk_update({
+      connector_config: sdk.options.configuration,
+      data
+    });
+    return fulfillments2;
+  } catch (error) {
+    throw error;
+  }
+};
+var bulk_delete16 = async (props) => {
+  try {
+    const { sdk, ids } = props;
+    const adapter = await sdk.adapter();
+    if (!adapter) throw new Error("Adapter not found");
+    await adapter.fulfillments.bulk_delete({
+      connector_config: sdk.options.configuration,
+      ids
+    });
+    return;
+  } catch (error) {
+    throw error;
+  }
+};
+var fulfillments = {
+  list: list16,
+  retrieve: retrieve16,
+  create: create16,
+  update: update16,
+  delete: _delete16,
+  bulk_create: bulk_create16,
+  bulk_update: bulk_update16,
+  bulk_delete: bulk_delete16
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BaseService,
-  ConnectorLoader,
-  ErrorCodes,
-  Logger,
-  MockConnectorPlugin,
-  OrdersService,
-  PluginManager,
-  ProductsService,
-  StallConnectorError,
-  StallCore,
-  createErrorResponse,
-  createLogger,
-  generateRequestId,
-  handleConnectorError
+  categories,
+  collections,
+  customers,
+  fulfillments,
+  initializeStallCore,
+  inventory_levels,
+  locations,
+  order_notes,
+  orders,
+  payment_providers,
+  payments,
+  products,
+  promotions,
+  refunds,
+  tax_rates,
+  tax_regions,
+  variants
 });