@edgebound/bigcommerce 0.1.3 → 0.2.0

package/dist/companies.js

@@ -1,2 +1,725 @@
 "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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/bigcommerce-entities/companies/index.ts
+var companies_exports = {};
+__export(companies_exports, {
+  AssignSalesStaffResponseSchema: () => AssignSalesStaffResponseSchema,
+  AssignSalesStaffSchema: () => AssignSalesStaffSchema,
+  CompanyExtraFieldSchema: () => CompanyExtraFieldSchema,
+  CompanyRoleSchema: () => CompanyRoleSchema,
+  CreateCompanyResponseSchema: () => CreateCompanyResponseSchema,
+  CreateCompanySchema: () => CreateCompanySchema,
+  CreateCompanyUserResponseSchema: () => CreateCompanyUserResponseSchema,
+  CreateCompanyUserSchema: () => CreateCompanyUserSchema,
+  GetCompanyExtraFieldsCriteriaSchema: () => GetCompanyExtraFieldsCriteriaSchema,
+  GetCompanyExtraFieldsResponseSchema: () => GetCompanyExtraFieldsResponseSchema,
+  GetCompanyRolesCriteriaSchema: () => GetCompanyRolesCriteriaSchema,
+  GetCompanyRolesResponseSchema: () => GetCompanyRolesResponseSchema,
+  SetCompanyCreditResponseSchema: () => SetCompanyCreditResponseSchema,
+  SetCompanyCreditSchema: () => SetCompanyCreditSchema,
+  SetCompanyPaymentMethodsResponseSchema: () => SetCompanyPaymentMethodsResponseSchema,
+  SetCompanyPaymentMethodsSchema: () => SetCompanyPaymentMethodsSchema,
+  assignSalesStaffToCompany: () => assignSalesStaffToCompany,
+  createCompany: () => createCompany,
+  createCompanyUser: () => createCompanyUser,
+  findCompanyExtraFields: () => findCompanyExtraFields,
+  findCompanyRoles: () => findCompanyRoles,
+  getAllCompanyExtraFieldsBy: () => getAllCompanyExtraFieldsBy,
+  getAllCompanyRolesBy: () => getAllCompanyRolesBy,
+  setCompanyCredit: () => setCompanyCredit,
+  setCompanyPaymentMethods: () => setCompanyPaymentMethods
+});
+module.exports = __toCommonJS(companies_exports);
+
+// src/bigcommerce-entities/companies/assign-sales-staff.ts
+var import_effect8 = require("effect");
+
+// src/constants.ts
+var import_effect = require("effect");
+var DEFAULTS = {
+  retry: {
+    policy: import_effect.Schedule.exponential(import_effect.Duration.millis(200), 2).pipe(
+      import_effect.Schedule.intersect(import_effect.Schedule.recurs(3))
+    )
+  },
+  timeout: {
+    ms: 3e4
+  },
+  bigcommerceUrls: {
+    b2b: "https://api-b2b.bigcommerce.com/api",
+    regular: "https://api.bigcommerce.com/stores"
+  },
+  customers: {
+    getBatchSize: 250
+  },
+  salesStaff: {
+    getBatchSize: 250
+  },
+  companies: {
+    salesStaffAssignments: {
+      assignBatchSize: 10,
+      concurrency: 2
+    },
+    extraFields: {
+      getBatchSize: 250
+    },
+    roles: {
+      getBatchSize: 250
+    }
+  },
+  products: {
+    updateBatchSize: 5,
+    updateConcurrency: 2,
+    inventory: {
+      updateBatchSize: 2e3,
+      updateConcurrency: 2
+    }
+  },
+  orders: {
+    getAllBatchSize: 250,
+    shippingAddresses: {
+      getAllBatchSize: 250
+    },
+    products: {
+      getAllBatchSize: 250
+    }
+  },
+  priceLists: {
+    getAllBatchSize: 250
+  }
+};
+
+// src/core/bigcommerce.error.ts
+var import_effect2 = require("effect");
+var BigCommerceUnprocessableEntityError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceUnprocessableEntityError"
+) {
+};
+var BigCommerceUnauthorizedError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceUnauthorizedError"
+) {
+};
+var BigCommerceForbiddenError = class extends import_effect2.Data.TaggedError("BigCommerceForbiddenError") {
+};
+var BigCommerceNotFoundError = class extends import_effect2.Data.TaggedError("BigCommerceNotFoundError") {
+};
+var BigCommerceConflictError = class extends import_effect2.Data.TaggedError("BigCommerceConflictError") {
+};
+var BigCommerceConnectionError = class extends import_effect2.Data.TaggedError("BigCommerceConnectionError") {
+};
+var BigCommerceUnknownError = class extends import_effect2.Data.TaggedError("BigCommerceUnknownError") {
+};
+var BigCommerceInvalidResponseError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceInvalidResponseError"
+) {
+};
+var BigCommerceInvalidRequestError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceInvalidRequestError"
+) {
+};
+var BigCommerceParseResponseError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceParseResponseError"
+) {
+};
+
+// src/core/bigcommerce.fetcher.ts
+var import_effect3 = require("effect");
+var BigCommerceFetcher = class extends import_effect3.Context.Tag("BigCommerceFetcher")() {
+};
+
+// src/core/bigcommerce.fetcher.live.ts
+var import_effect5 = require("effect");
+
+// src/core/config.ts
+var import_effect4 = require("effect");
+var NoBigCommerceConfigError = class extends import_effect4.Data.TaggedError("NoBigCommerceConfigError") {
+};
+var BigCommerceConfig = class extends import_effect4.Context.Tag("BigCommerceConfig")() {
+};
+var getBigCommerceConfig = (key) => {
+  return import_effect4.Config.nested(import_effect4.Config.string(key), "BIGCOMMERCE").pipe(
+    import_effect4.Effect.mapError(() => new NoBigCommerceConfigError({ key }))
+  );
+};
+var getBigCommerceTimeout = () => {
+  return import_effect4.Config.nested(import_effect4.Config.number("TIMEOUT"), "BIGCOMMERCE").pipe(
+    import_effect4.Effect.mapError(() => new NoBigCommerceConfigError({ key: "TIMEOUT" })),
+    // Default to 30 seconds if not configured
+    import_effect4.Effect.orElse(() => import_effect4.Effect.succeed(DEFAULTS.timeout.ms))
+  );
+};
+var BigCommerceConfigLive = import_effect4.Layer.effect(
+  BigCommerceConfig,
+  import_effect4.Effect.gen(function* () {
+    const [storeHash, clientId, clientSecret, accessToken, timeout] = yield* import_effect4.Effect.all([
+      getBigCommerceConfig("STORE_HASH"),
+      getBigCommerceConfig("CLIENT_ID"),
+      getBigCommerceConfig("CLIENT_SECRET"),
+      getBigCommerceConfig("ACCESS_TOKEN"),
+      getBigCommerceTimeout()
+    ]);
+    return {
+      getStoreHash: import_effect4.Effect.succeed(storeHash),
+      getClientId: import_effect4.Effect.succeed(clientId),
+      getClientSecret: import_effect4.Effect.succeed(clientSecret),
+      getAccessToken: import_effect4.Effect.succeed(accessToken),
+      getTimeout: import_effect4.Effect.succeed(timeout)
+    };
+  })
+);
+var BigCommerceConfigTest = import_effect4.Layer.succeed(BigCommerceConfig, {
+  getAccessToken: import_effect4.Effect.succeed("test"),
+  getClientId: import_effect4.Effect.succeed("test"),
+  getClientSecret: import_effect4.Effect.succeed("test"),
+  getStoreHash: import_effect4.Effect.succeed("test"),
+  getTimeout: import_effect4.Effect.succeed(DEFAULTS.timeout.ms)
+});
+
+// src/core/bigcommerce.fetcher.live.ts
+var BigCommerceStatusCodes = {
+  UNAUTHORIZED: 401,
+  CONFLICT: 409,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  INVALID_REQUEST: 400
+};
+var BigCommerceFetcherLive = import_effect5.Layer.effect(
+  BigCommerceFetcher,
+  import_effect5.Effect.gen(function* () {
+    const config = yield* BigCommerceConfig;
+    const storeHash = yield* config.getStoreHash;
+    const accessToken = yield* config.getAccessToken;
+    const timeout = yield* config.getTimeout;
+    return {
+      fetch: (params) => {
+        const base = getBase(params);
+        const headers = {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          "x-auth-token": accessToken
+        };
+        if (params.isB2B) {
+          headers["x-store-hash"] = storeHash;
+        }
+        const url = applyParams(base.replace("[storeHash]", storeHash), params.query);
+        return import_effect5.Effect.tryPromise({
+          try: () => fetch(url, {
+            headers,
+            signal: AbortSignal.timeout(timeout),
+            method: params.method,
+            ...params.body && { body: JSON.stringify(params.body) }
+          }),
+          catch: (error) => {
+            if (error instanceof Error && error.name === "TimeoutError") {
+              return new BigCommerceConnectionError({
+                message: `Request timeout after ${timeout}ms`,
+                type: "timeout"
+              });
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+              return new BigCommerceConnectionError({
+                message: `Request timeout after ${timeout}ms`,
+                type: "timeout"
+              });
+            }
+            return new BigCommerceUnknownError({ cause: error });
+          }
+        }).pipe(
+          import_effect5.Effect.tapError(
+            (error) => import_effect5.Effect.logError("Failed to fetch from BigCommerce API", error.cause)
+          ),
+          import_effect5.Effect.flatMap((response) => transformResponse(response, params.resultSchema))
+        );
+      }
+    };
+  })
+);
+var applyParams = (url, params) => {
+  const base = new URL(url);
+  if (!params) {
+    return base;
+  }
+  if (typeof params === "string") {
+    base.search = params;
+  } else {
+    for (const [key, value] of Object.entries(params)) {
+      base.searchParams.append(key, `${value}`);
+    }
+  }
+  return base;
+};
+var getBase = ({
+  isB2B,
+  path,
+  version
+}) => {
+  if (isB2B) {
+    return `${DEFAULTS.bigcommerceUrls.b2b}/${version}/io/${path}`;
+  }
+  return `${DEFAULTS.bigcommerceUrls.regular}/[storeHash]/${version}/${path}`;
+};
+function processSuccessResponse(response, schema) {
+  return import_effect5.Effect.tryPromise({
+    try: () => response.json(),
+    catch: (error) => new BigCommerceInvalidResponseError({ cause: error })
+  }).pipe(
+    import_effect5.Effect.tapError(
+      (error) => import_effect5.Effect.logError("Error parsing response from BigCommerce API", error.cause)
+    ),
+    import_effect5.Effect.tryMap({
+      try: (json) => schema.parse(json),
+      catch: (error) => new BigCommerceParseResponseError({ error })
+    })
+  );
+}
+var processErrorResponse = (response) => {
+  const code = response.status;
+  return import_effect5.Effect.tryPromise({
+    try: () => response.json(),
+    catch: (error) => new BigCommerceInvalidResponseError({ cause: error })
+  }).pipe(
+    import_effect5.Effect.tapError((error) => import_effect5.Effect.logError("Error parsing error response", error.cause)),
+    import_effect5.Effect.flatMap(
+      (errorDetails) => import_effect5.Effect.fail(
+        import_effect5.Match.value(code).pipe(
+          import_effect5.Match.when(
+            BigCommerceStatusCodes.INVALID_REQUEST,
+            () => new BigCommerceInvalidRequestError({ errorDetails })
+          ),
+          import_effect5.Match.when(BigCommerceStatusCodes.UNAUTHORIZED, () => new BigCommerceUnauthorizedError()),
+          import_effect5.Match.when(BigCommerceStatusCodes.FORBIDDEN, () => new BigCommerceForbiddenError()),
+          import_effect5.Match.when(BigCommerceStatusCodes.NOT_FOUND, () => new BigCommerceNotFoundError()),
+          import_effect5.Match.when(
+            BigCommerceStatusCodes.CONFLICT,
+            () => new BigCommerceConflictError({ details: errorDetails })
+          ),
+          import_effect5.Match.when(
+            BigCommerceStatusCodes.UNPROCESSABLE_ENTITY,
+            () => new BigCommerceUnprocessableEntityError({ errorDetails })
+          ),
+          import_effect5.Match.when(
+            (code2) => code2 >= 500,
+            () => new BigCommerceConnectionError({
+              message: `Server error: ${code}`,
+              type: code === BigCommerceStatusCodes.INTERNAL_SERVER_ERROR ? "internalError" : code === BigCommerceStatusCodes.BAD_GATEWAY || code === BigCommerceStatusCodes.GATEWAY_TIMEOUT ? "timeout" : "internalError"
+            })
+          ),
+          import_effect5.Match.orElse(() => new BigCommerceUnknownError({ cause: errorDetails }))
+        )
+      )
+    )
+  );
+};
+var transformResponse = (response, schema) => {
+  if (response.ok) {
+    return processSuccessResponse(response, schema);
+  }
+  return processErrorResponse(response);
+};
+
+// src/validation/index.ts
+var import_effect7 = require("effect");
+
+// src/validation/validation.error.ts
+var import_effect6 = require("effect");
+var InputValidationError = class extends import_effect6.Data.TaggedError("InputValidationError") {
+};
+
+// src/validation/index.ts
+var validateInput = (schema, data) => {
+  return import_effect7.Effect.try({
+    try: () => schema.parse(data),
+    catch: (error) => new InputValidationError({ input: data, error })
+  });
+};
+
+// src/bigcommerce-entities/companies/schemas/company.schema.ts
+var z = __toESM(require("zod"));
+var CreateCompanySchema = z.object({
+  companyName: z.string(),
+  companyPhone: z.string(),
+  companyEmail: z.string(),
+  addressLine1: z.string(),
+  addressLine2: z.string(),
+  city: z.string(),
+  state: z.string(),
+  country: z.string(),
+  zipCode: z.string(),
+  adminFirstName: z.string(),
+  adminLastName: z.string(),
+  adminEmail: z.string(),
+  adminPhoneNumber: z.string(),
+  acceptCreationEmail: z.boolean(),
+  uuid: z.string(),
+  channelIds: z.array(z.int()),
+  originChannelId: z.int(),
+  customerGroupId: z.int(),
+  extraFields: z.array(
+    z.object({
+      fieldName: z.string(),
+      fieldValue: z.string()
+    })
+  )
+});
+var CreateCompanyResponseSchema = z.object({
+  data: z.object({
+    companyId: z.int()
+  }),
+  meta: z.object({
+    message: z.string()
+  })
+});
+
+// src/bigcommerce-entities/companies/schemas/credit.schemas.ts
+var z2 = __toESM(require("zod"));
+var SetCompanyCreditSchema = z2.object({
+  data: z2.object({
+    creditEnabled: z2.boolean(),
+    creditCurrency: z2.enum(["MXN"]),
+    availableCredit: z2.number(),
+    limitPurchases: z2.boolean(),
+    creditHold: z2.boolean()
+  }),
+  companyId: z2.int()
+});
+var SetCompanyCreditResponseSchema = z2.object({});
+
+// src/bigcommerce-entities/companies/schemas/extra-fields.schema.ts
+var z3 = __toESM(require("zod"));
+var GetCompanyExtraFieldsCriteriaSchema = z3.object({
+  limit: z3.int().max(DEFAULTS.companies.extraFields.getBatchSize).optional(),
+  offset: z3.int().optional()
+});
+var CompanyExtraFieldSchema = z3.object({
+  fieldName: z3.string(),
+  labelName: z3.string(),
+  listOfValue: z3.string().array().optional(),
+  maximumLength: z3.coerce.number().optional()
+});
+var GetCompanyExtraFieldsResponseSchema = z3.object({
+  data: CompanyExtraFieldSchema.array(),
+  meta: z3.object({
+    message: z3.string(),
+    pagination: z3.object({
+      totalCount: z3.number(),
+      offset: z3.number(),
+      limit: z3.number()
+    })
+  })
+});
+
+// src/bigcommerce-entities/companies/schemas/payment-methods.schema.ts
+var z4 = __toESM(require("zod"));
+var SetCompanyPaymentMethodsSchema = z4.object({
+  data: z4.object({
+    payments: z4.object({
+      code: z4.string(),
+      isEnabled: z4.boolean()
+    }).array()
+  }),
+  companyId: z4.int()
+});
+var SetCompanyPaymentMethodsResponseSchema = z4.object({});
+
+// src/bigcommerce-entities/companies/schemas/roles.ts
+var z5 = __toESM(require("zod"));
+var CompanyRoleSchema = z5.object({
+  id: z5.int(),
+  name: z5.string(),
+  roleLevel: z5.number(),
+  roleType: z5.number()
+});
+var GetCompanyRolesCriteriaSchema = z5.object({
+  limit: z5.int().optional(),
+  offset: z5.int().optional()
+});
+var GetCompanyRolesResponseSchema = z5.object({
+  data: CompanyRoleSchema.array(),
+  meta: z5.object({
+    message: z5.string(),
+    pagination: z5.object({
+      limit: z5.number(),
+      offset: z5.number(),
+      totalCount: z5.number()
+    })
+  })
+});
+
+// src/bigcommerce-entities/companies/schemas/sales-staff.schema.ts
+var z6 = __toESM(require("zod"));
+var AssignSalesStaffSchema = z6.object({
+  assignments: z6.array(
+    z6.object({
+      assignStatus: z6.boolean(),
+      companyId: z6.int()
+    })
+  ),
+  salesStaffId: z6.int().transform(String)
+});
+var AssignSalesStaffResponseSchema = z6.object({
+  code: z6.int(),
+  meta: z6.object({
+    message: z6.string()
+  })
+});
+
+// src/bigcommerce-entities/companies/schemas/user.schema.ts
+var z7 = __toESM(require("zod"));
+var CreateCompanyUserSchema = z7.object({
+  acceptWelcomeEmail: z7.boolean(),
+  companyId: z7.int(),
+  companyRoleId: z7.int(),
+  email: z7.email(),
+  firstName: z7.string(),
+  lastName: z7.string(),
+  phoneNumber: z7.string()
+});
+var CreateCompanyUserResponseSchema = z7.object({
+  code: z7.number(),
+  data: z7.object({
+    bcId: z7.number(),
+    userId: z7.int()
+  }),
+  meta: z7.object({
+    message: z7.string()
+  })
+});
+
+// src/bigcommerce-entities/companies/assign-sales-staff.ts
+var assignSalesStaffToCompanyBatch = (staffId, assignments) => import_effect8.Effect.gen(function* () {
+  const fetcher = yield* BigCommerceFetcher;
+  return yield* import_effect8.Effect.retry(
+    fetcher.fetch({
+      isB2B: true,
+      method: "PUT",
+      path: `sales-staffs/${staffId}`,
+      version: "v3",
+      body: assignments,
+      resultSchema: AssignSalesStaffResponseSchema
+    }),
+    DEFAULTS.retry.policy
+  );
+});
+var assignSalesStaffToCompany = (input) => import_effect8.Effect.gen(function* () {
+  const validatedInput = yield* validateInput(AssignSalesStaffSchema, input);
+  return yield* import_effect8.Stream.fromIterable(validatedInput.assignments).pipe(
+    import_effect8.Stream.grouped(DEFAULTS.companies.salesStaffAssignments.assignBatchSize),
+    import_effect8.Stream.mapEffect(
+      (chunk) => assignSalesStaffToCompanyBatch(validatedInput.salesStaffId, import_effect8.Chunk.toArray(chunk)),
+      { concurrency: DEFAULTS.companies.salesStaffAssignments.concurrency }
+    ),
+    import_effect8.Stream.runCollect,
+    import_effect8.Effect.map(import_effect8.Chunk.toArray)
+  );
+});
+
+// src/bigcommerce-entities/companies/create-company.ts
+var import_effect9 = require("effect");
+var createCompany = (data) => import_effect9.Effect.gen(function* () {
+  const fetcher = yield* BigCommerceFetcher;
+  const validatedData = yield* validateInput(CreateCompanySchema, data);
+  return yield* import_effect9.Effect.retry(
+    fetcher.fetch({
+      isB2B: true,
+      method: "POST",
+      path: "companies",
+      resultSchema: CreateCompanyResponseSchema,
+      version: "v3",
+      body: validatedData
+    }),
+    DEFAULTS.retry.policy
+  );
+});
+
+// src/bigcommerce-entities/companies/create-company-user.ts
+var import_effect10 = require("effect");
+var createCompanyUser = (data) => import_effect10.Effect.gen(function* () {
+  const validatedData = yield* validateInput(CreateCompanyUserSchema, data);
+  const fetcher = yield* BigCommerceFetcher;
+  return yield* import_effect10.Effect.retry(
+    fetcher.fetch({
+      body: validatedData,
+      isB2B: true,
+      method: "POST",
+      path: "users",
+      resultSchema: CreateCompanyUserResponseSchema,
+      version: "v3"
+    }),
+    DEFAULTS.retry.policy
+  );
+});
+
+// src/bigcommerce-entities/companies/credit.ts
+var import_effect11 = require("effect");
+var setCompanyCredit = (input) => import_effect11.Effect.gen(function* () {
+  const { companyId, data } = yield* validateInput(SetCompanyCreditSchema, input);
+  const fetcher = yield* BigCommerceFetcher;
+  return yield* import_effect11.Effect.retry(
+    fetcher.fetch({
+      body: data,
+      isB2B: true,
+      method: "PUT",
+      path: `companies/${companyId}/credit`,
+      resultSchema: SetCompanyCreditResponseSchema,
+      version: "v3"
+    }),
+    DEFAULTS.retry.policy
+  );
+});
+
+// src/bigcommerce-entities/companies/get-company-fields.ts
+var import_effect12 = require("effect");
+var import_qs = __toESM(require("qs"));
+var findCompanyExtraFields = (criteria) => import_effect12.Effect.gen(function* () {
+  const validatedCriteria = yield* validateInput(GetCompanyExtraFieldsCriteriaSchema, criteria);
+  const fetcher = yield* BigCommerceFetcher;
+  return yield* import_effect12.Effect.retry(
+    fetcher.fetch({
+      isB2B: true,
+      method: "GET",
+      query: import_qs.default.stringify(validatedCriteria),
+      path: "companies/extra-fields",
+      resultSchema: GetCompanyExtraFieldsResponseSchema,
+      version: "v3"
+    }),
+    DEFAULTS.retry.policy
+  );
+});
+var getAllCompanyExtraFieldsBy = (criteria) => import_effect12.Effect.gen(function* () {
+  let offset = 0;
+  const limit = DEFAULTS.companies.extraFields.getBatchSize;
+  let hasMore = true;
+  const data = [];
+  while (hasMore) {
+    const response = yield* findCompanyExtraFields({
+      ...criteria,
+      limit,
+      offset
+    });
+    if (response.data.length) {
+      offset += limit;
+      data.push(...response.data);
+    } else {
+      hasMore = false;
+    }
+  }
+  return data;
+});
+
+// src/bigcommerce-entities/companies/get-company-roles.ts
+var import_effect13 = require("effect");
+var import_qs2 = __toESM(require("qs"));
+var findCompanyRoles = (criteria) => import_effect13.Effect.gen(function* () {
+  const validatedCriteria = yield* validateInput(GetCompanyRolesCriteriaSchema, criteria);
+  const fetcher = yield* BigCommerceFetcher;
+  return yield* import_effect13.Effect.retry(
+    fetcher.fetch({
+      isB2B: true,
+      method: "GET",
+      query: import_qs2.default.stringify(validatedCriteria),
+      path: "companies/roles",
+      resultSchema: GetCompanyRolesResponseSchema,
+      version: "v3"
+    }),
+    DEFAULTS.retry.policy
+  );
+});
+var getAllCompanyRolesBy = (criteria) => import_effect13.Effect.gen(function* () {
+  let hasMore = true;
+  const data = [];
+  let offset = 0;
+  const limit = DEFAULTS.companies.roles.getBatchSize;
+  while (hasMore) {
+    const response = yield* findCompanyRoles({
+      ...criteria,
+      limit,
+      offset
+    });
+    if (response.data.length) {
+      offset += limit;
+      data.push(...response.data);
+    } else {
+      hasMore = false;
+    }
+  }
+  return data;
+});
+
+// src/bigcommerce-entities/companies/set-payment-methods.ts
+var import_effect14 = require("effect");
+var setCompanyPaymentMethods = (input) => import_effect14.Effect.gen(function* () {
+  const { companyId, data } = yield* validateInput(SetCompanyPaymentMethodsSchema, input);
+  const fetcher = yield* BigCommerceFetcher;
+  return yield* import_effect14.Effect.retry(
+    fetcher.fetch({
+      body: data,
+      isB2B: true,
+      method: "PUT",
+      path: `companies/${companyId}/payments`,
+      resultSchema: SetCompanyPaymentMethodsResponseSchema,
+      version: "v3"
+    }),
+    DEFAULTS.retry.policy
+  );
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssignSalesStaffResponseSchema,
+  AssignSalesStaffSchema,
+  CompanyExtraFieldSchema,
+  CompanyRoleSchema,
+  CreateCompanyResponseSchema,
+  CreateCompanySchema,
+  CreateCompanyUserResponseSchema,
+  CreateCompanyUserSchema,
+  GetCompanyExtraFieldsCriteriaSchema,
+  GetCompanyExtraFieldsResponseSchema,
+  GetCompanyRolesCriteriaSchema,
+  GetCompanyRolesResponseSchema,
+  SetCompanyCreditResponseSchema,
+  SetCompanyCreditSchema,
+  SetCompanyPaymentMethodsResponseSchema,
+  SetCompanyPaymentMethodsSchema,
+  assignSalesStaffToCompany,
+  createCompany,
+  createCompanyUser,
+  findCompanyExtraFields,
+  findCompanyRoles,
+  getAllCompanyExtraFieldsBy,
+  getAllCompanyRolesBy,
+  setCompanyCredit,
+  setCompanyPaymentMethods
+});
 //# sourceMappingURL=companies.js.map