@deliverart/sdk-js-customer 0.0.1

package/dist/index.cjs

@@ -0,0 +1,747 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CreateCustomer: () => CreateCustomer,
+  CreateCustomerAddress: () => CreateCustomerAddress,
+  CreateCustomerBusinessProfile: () => CreateCustomerBusinessProfile,
+  DeleteCustomer: () => DeleteCustomer,
+  DeleteCustomerAddress: () => DeleteCustomerAddress,
+  DeleteCustomerBusinessProfile: () => DeleteCustomerBusinessProfile,
+  GetCustomerAddressDetails: () => GetCustomerAddressDetails,
+  GetCustomerAddresses: () => GetCustomerAddresses,
+  GetCustomerAddressesForCustomer: () => GetCustomerAddressesForCustomer,
+  GetCustomerBusinessProfileDetails: () => GetCustomerBusinessProfileDetails,
+  GetCustomerBusinessProfiles: () => GetCustomerBusinessProfiles,
+  GetCustomerBusinessProfilesForCustomer: () => GetCustomerBusinessProfilesForCustomer,
+  GetCustomerDetails: () => GetCustomerDetails,
+  GetCustomers: () => GetCustomers,
+  UpdateCustomer: () => UpdateCustomer,
+  UpdateCustomerAddress: () => UpdateCustomerAddress,
+  UpdateCustomerBusinessProfile: () => UpdateCustomerBusinessProfile,
+  createCustomerAddressInputSchema: () => createCustomerAddressInputSchema,
+  createCustomerAddressResponseSchema: () => createCustomerAddressResponseSchema,
+  createCustomerBusinessProfileInputSchema: () => createCustomerBusinessProfileInputSchema,
+  createCustomerBusinessProfileResponseSchema: () => createCustomerBusinessProfileResponseSchema,
+  createCustomerInputSchema: () => createCustomerInputSchema,
+  createCustomerResponseSchema: () => createCustomerResponseSchema,
+  customerAddressDetailsSchema: () => customerAddressDetailsSchema,
+  customerAddressNullablePathSchema: () => customerAddressNullablePathSchema,
+  customerAddressPathSchema: () => customerAddressPathSchema,
+  customerAddressSchema: () => customerAddressSchema,
+  customerBusinessProfileDetailsSchema: () => customerBusinessProfileDetailsSchema,
+  customerBusinessProfileNullablePathSchema: () => customerBusinessProfileNullablePathSchema,
+  customerBusinessProfilePathSchema: () => customerBusinessProfilePathSchema,
+  customerBusinessProfileSchema: () => customerBusinessProfileSchema,
+  customerDetailsSchema: () => customerDetailsSchema,
+  customerNullablePathSchema: () => customerNullablePathSchema,
+  customerPathSchema: () => customerPathSchema,
+  customerSchema: () => customerSchema,
+  deleteCustomerAddressInputSchema: () => deleteCustomerAddressInputSchema,
+  deleteCustomerAddressResponseSchema: () => deleteCustomerAddressResponseSchema,
+  deleteCustomerBusinessProfileInputSchema: () => deleteCustomerBusinessProfileInputSchema,
+  deleteCustomerBusinessProfileResponseSchema: () => deleteCustomerBusinessProfileResponseSchema,
+  deleteCustomerInputSchema: () => deleteCustomerInputSchema,
+  deleteCustomerResponseSchema: () => deleteCustomerResponseSchema,
+  getCustomerAddressDetailsInputSchema: () => getCustomerAddressDetailsInputSchema,
+  getCustomerAddressDetailsResponseSchema: () => getCustomerAddressDetailsResponseSchema,
+  getCustomerAddressesForCustomerInputSchema: () => getCustomerAddressesForCustomerInputSchema,
+  getCustomerAddressesForCustomerQuerySchema: () => getCustomerAddressesForCustomerQuerySchema,
+  getCustomerAddressesForCustomerResponseSchema: () => getCustomerAddressesForCustomerResponseSchema,
+  getCustomerAddressesInputSchema: () => getCustomerAddressesInputSchema,
+  getCustomerAddressesQuerySchema: () => getCustomerAddressesQuerySchema,
+  getCustomerAddressesResponseSchema: () => getCustomerAddressesResponseSchema,
+  getCustomerBusinessProfileDetailsInputSchema: () => getCustomerBusinessProfileDetailsInputSchema,
+  getCustomerBusinessProfileDetailsResponseSchema: () => getCustomerBusinessProfileDetailsResponseSchema,
+  getCustomerBusinessProfilesForCustomerInputSchema: () => getCustomerBusinessProfilesForCustomerInputSchema,
+  getCustomerBusinessProfilesForCustomerQuerySchema: () => getCustomerBusinessProfilesForCustomerQuerySchema,
+  getCustomerBusinessProfilesForCustomerResponseSchema: () => getCustomerBusinessProfilesForCustomerResponseSchema,
+  getCustomerBusinessProfilesInputSchema: () => getCustomerBusinessProfilesInputSchema,
+  getCustomerBusinessProfilesQuerySchema: () => getCustomerBusinessProfilesQuerySchema,
+  getCustomerBusinessProfilesResponseSchema: () => getCustomerBusinessProfilesResponseSchema,
+  getCustomerDetailsInputSchema: () => getCustomerDetailsInputSchema,
+  getCustomerDetailsResponseSchema: () => getCustomerDetailsResponseSchema,
+  getCustomersInputSchema: () => getCustomersInputSchema,
+  getCustomersQuerySchema: () => getCustomersQuerySchema,
+  getCustomersResponseSchema: () => getCustomersResponseSchema,
+  updateCustomerAddressInputSchema: () => updateCustomerAddressInputSchema,
+  updateCustomerAddressResponseSchema: () => updateCustomerAddressResponseSchema,
+  updateCustomerBusinessProfileInputSchema: () => updateCustomerBusinessProfileInputSchema,
+  updateCustomerBusinessProfileResponseSchema: () => updateCustomerBusinessProfileResponseSchema,
+  updateCustomerInputSchema: () => updateCustomerInputSchema,
+  updateCustomerResponseSchema: () => updateCustomerResponseSchema,
+  writableCreateCustomerAddressSchema: () => writableCreateCustomerAddressSchema,
+  writableCreateCustomerBusinessProfileSchema: () => writableCreateCustomerBusinessProfileSchema,
+  writableCreateCustomerSchema: () => writableCreateCustomerSchema,
+  writableCustomerAddressSchema: () => writableCustomerAddressSchema,
+  writableCustomerBusinessProfileSchema: () => writableCustomerBusinessProfileSchema,
+  writableCustomerSchema: () => writableCustomerSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/models.ts
+var import_sdk_js_global_types = require("@deliverart/sdk-js-global-types");
+var import_sdk_js_point_of_sale = require("@deliverart/sdk-js-point-of-sale");
+var import_sdk_js_user = require("@deliverart/sdk-js-user");
+var import_zod2 = require("zod");
+
+// src/types.ts
+var import_zod = require("zod");
+var customerPathSchema = import_zod.z.string().refine((val) => /^\/customers\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val), {
+  message: "Invalid customer path format"
+});
+var customerNullablePathSchema = import_zod.z.string().nullable().refine(
+  (val) => {
+    if (!val) return true;
+    return /^\/customers\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val);
+  },
+  {
+    message: "Invalid customer path format"
+  }
+);
+var customerAddressPathSchema = import_zod.z.string().refine((val) => /^\/customers\/addresses\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val), {
+  message: "Invalid customerAddress path format"
+});
+var customerAddressNullablePathSchema = import_zod.z.string().nullable().refine(
+  (val) => {
+    if (!val) return true;
+    return /^\/customers\/addresses\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val);
+  },
+  {
+    message: "Invalid customerAddress path format"
+  }
+);
+var customerBusinessProfilePathSchema = import_zod.z.string().refine((val) => /^\/customers\/business_profiles\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val), {
+  message: "Invalid customerBusinessProfile path format"
+});
+var customerBusinessProfileNullablePathSchema = import_zod.z.string().nullable().refine(
+  (val) => {
+    if (!val) return true;
+    return /^\/customers\/business_profiles\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val);
+  },
+  {
+    message: "Invalid customerBusinessProfile path format"
+  }
+);
+
+// src/models.ts
+var customerSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  firstName: import_zod2.z.string().nullable(),
+  lastName: import_zod2.z.string().nullable(),
+  email: import_zod2.z.string().email().nullable(),
+  phoneNumber: import_zod2.z.string().nullable(),
+  hasBusinessProfiles: import_zod2.z.boolean(),
+  hasAddresses: import_zod2.z.boolean(),
+  ordersPlaced: import_zod2.z.number(),
+  totalSpent: import_zod2.z.number(),
+  createdAt: import_sdk_js_global_types.datetimeSchema,
+  updatedAt: import_sdk_js_global_types.datetimeSchema
+});
+var customerDetailsSchema = customerSchema.extend({
+  pointOfSale: import_sdk_js_point_of_sale.pointOfSaleNullablePathSchema,
+  owner: import_sdk_js_user.userNullablePathSchema,
+  addresses: import_zod2.z.array(customerAddressPathSchema),
+  businessProfiles: import_zod2.z.array(customerBusinessProfilePathSchema)
+});
+var writableCreateCustomerSchema = customerDetailsSchema.pick({
+  pointOfSale: true,
+  firstName: true,
+  lastName: true,
+  email: true,
+  phoneNumber: true
+});
+var writableCustomerSchema = writableCreateCustomerSchema.omit({
+  pointOfSale: true
+});
+var customerAddressSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  address: import_sdk_js_global_types.addressSchema,
+  location: import_sdk_js_global_types.locationSchema,
+  createdAt: import_sdk_js_global_types.datetimeSchema,
+  updatedAt: import_sdk_js_global_types.datetimeSchema
+});
+var customerAddressDetailsSchema = customerAddressSchema.extend({
+  customer: customerPathSchema
+});
+var writableCreateCustomerAddressSchema = customerAddressDetailsSchema.pick({
+  customer: true,
+  address: true
+});
+var writableCustomerAddressSchema = writableCreateCustomerAddressSchema.omit({
+  customer: true
+});
+var customerBusinessProfileSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  businessName: import_zod2.z.string(),
+  vat: import_zod2.z.string(),
+  taxCode: import_zod2.z.string(),
+  billingAddress: import_sdk_js_global_types.addressSchema,
+  billingData: import_sdk_js_global_types.billingDataSchema,
+  createdAt: import_sdk_js_global_types.datetimeSchema,
+  updatedAt: import_sdk_js_global_types.datetimeSchema
+});
+var customerBusinessProfileDetailsSchema = customerBusinessProfileSchema.extend({
+  customer: customerPathSchema
+});
+var writableCreateCustomerBusinessProfileSchema = customerBusinessProfileDetailsSchema.pick({
+  customer: true,
+  businessName: true,
+  vat: true,
+  taxCode: true,
+  billingAddress: true,
+  billingData: true
+});
+var writableCustomerBusinessProfileSchema = writableCreateCustomerBusinessProfileSchema.omit({
+  customer: true
+});
+
+// src/requests/customer-addresses/CreateCustomerAddress.ts
+var import_sdk_js_core = require("@deliverart/sdk-js-core");
+var createCustomerAddressInputSchema = writableCreateCustomerAddressSchema.required();
+var createCustomerAddressResponseSchema = customerAddressDetailsSchema;
+var CreateCustomerAddress = class extends import_sdk_js_core.AbstractApiRequest {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createCustomerAddressInputSchema;
+  outputSchema = createCustomerAddressResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/customers/addresses";
+  }
+};
+
+// src/requests/customer-addresses/DeleteCustomerAddress.ts
+var import_sdk_js_core2 = require("@deliverart/sdk-js-core");
+var import_zod3 = require("zod");
+var deleteCustomerAddressInputSchema = import_zod3.z.undefined();
+var deleteCustomerAddressResponseSchema = import_zod3.z.undefined();
+var DeleteCustomerAddress = class extends import_sdk_js_core2.AbstractApiRequest {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteCustomerAddressInputSchema;
+  outputSchema = deleteCustomerAddressResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerAddressId;
+  constructor(customerAddressId) {
+    super();
+    this.customerAddressId = customerAddressId;
+  }
+  getPath() {
+    return `/customers/addresses/${this.customerAddressId}`;
+  }
+};
+
+// src/requests/customer-addresses/GetCustomerAddressDetails.ts
+var import_sdk_js_core3 = require("@deliverart/sdk-js-core");
+var import_zod4 = require("zod");
+var getCustomerAddressDetailsInputSchema = import_zod4.z.undefined();
+var getCustomerAddressDetailsResponseSchema = customerAddressDetailsSchema;
+var GetCustomerAddressDetails = class extends import_sdk_js_core3.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCustomerAddressDetailsInputSchema;
+  outputSchema = getCustomerAddressDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerAddressId;
+  constructor(customerAddressId) {
+    super();
+    this.customerAddressId = customerAddressId;
+  }
+  getPath() {
+    return `/customers/addresses/${this.customerAddressId}`;
+  }
+};
+
+// src/requests/customer-addresses/GetCustomerAddresses.ts
+var import_sdk_js_core4 = require("@deliverart/sdk-js-core");
+var import_sdk_js_global_types2 = require("@deliverart/sdk-js-global-types");
+var import_zod5 = require("zod");
+var getCustomerAddressesQuerySchema = import_zod5.z.object({
+  "order[createdAt]": import_sdk_js_global_types2.sortDirSchema.optional(),
+  "order[updatedAt]": import_sdk_js_global_types2.sortDirSchema.optional(),
+  page: import_zod5.z.coerce.number().optional()
+}).merge(import_sdk_js_global_types2.timestampsFilterSchema);
+var getCustomerAddressesResponseSchema = (0, import_sdk_js_global_types2.createPaginatedSchema)(customerAddressSchema);
+var getCustomerAddressesInputSchema = import_zod5.z.undefined();
+var GetCustomerAddresses = class extends import_sdk_js_core4.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCustomerAddressesInputSchema;
+  outputSchema = getCustomerAddressesResponseSchema;
+  querySchema = getCustomerAddressesQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/customers/addresses";
+  }
+  parseResponse(data, rawResponse) {
+    const customerAddresses = import_zod5.z.array(customerAddressSchema).parse(data);
+    return this.validateOutput({
+      data: customerAddresses,
+      pagination: (0, import_sdk_js_global_types2.responseToPagination)(rawResponse)
+    });
+  }
+};
+
+// src/requests/customer-addresses/GetCustomerAddressesForCustomer.ts
+var import_sdk_js_core5 = require("@deliverart/sdk-js-core");
+var import_sdk_js_global_types3 = require("@deliverart/sdk-js-global-types");
+var import_zod6 = require("zod");
+var getCustomerAddressesForCustomerQuerySchema = import_zod6.z.object({
+  "order[createdAt]": import_sdk_js_global_types3.sortDirSchema.optional(),
+  "order[updatedAt]": import_sdk_js_global_types3.sortDirSchema.optional()
+}).merge(import_sdk_js_global_types3.timestampsFilterSchema);
+var getCustomerAddressesForCustomerResponseSchema = import_zod6.z.array(customerAddressSchema);
+var getCustomerAddressesForCustomerInputSchema = import_zod6.z.undefined();
+var GetCustomerAddressesForCustomer = class extends import_sdk_js_core5.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCustomerAddressesForCustomerInputSchema;
+  outputSchema = getCustomerAddressesForCustomerResponseSchema;
+  querySchema = getCustomerAddressesForCustomerQuerySchema;
+  headersSchema = void 0;
+  customerId;
+  constructor(customerId, options) {
+    super(void 0, options);
+    this.customerId = customerId;
+  }
+  getPath() {
+    return `/customers/${this.customerId}/addresses`;
+  }
+  parseResponse(data) {
+    return import_zod6.z.array(customerAddressSchema).parse(data);
+  }
+};
+
+// src/requests/customer-addresses/UpdateCustomerAddress.ts
+var import_sdk_js_core6 = require("@deliverart/sdk-js-core");
+var updateCustomerAddressInputSchema = writableCustomerAddressSchema.partial();
+var updateCustomerAddressResponseSchema = customerAddressDetailsSchema;
+var UpdateCustomerAddress = class extends import_sdk_js_core6.AbstractApiRequest {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateCustomerAddressInputSchema;
+  outputSchema = updateCustomerAddressResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerId;
+  constructor(customerId, input) {
+    super(input);
+    this.customerId = customerId;
+  }
+  getPath() {
+    return `/customers/addresses/${this.customerId}`;
+  }
+};
+
+// src/requests/customer-business-profiles/CreateCustomerBusinessProfile.ts
+var import_sdk_js_core7 = require("@deliverart/sdk-js-core");
+var createCustomerBusinessProfileInputSchema = writableCreateCustomerBusinessProfileSchema.required();
+var createCustomerBusinessProfileResponseSchema = customerBusinessProfileDetailsSchema;
+var CreateCustomerBusinessProfile = class extends import_sdk_js_core7.AbstractApiRequest {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createCustomerBusinessProfileInputSchema;
+  outputSchema = createCustomerBusinessProfileResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/customers/business_profiles";
+  }
+};
+
+// src/requests/customer-business-profiles/DeleteCustomerBusinessProfile.ts
+var import_sdk_js_core8 = require("@deliverart/sdk-js-core");
+var import_zod7 = require("zod");
+var deleteCustomerBusinessProfileInputSchema = import_zod7.z.undefined();
+var deleteCustomerBusinessProfileResponseSchema = import_zod7.z.undefined();
+var DeleteCustomerBusinessProfile = class extends import_sdk_js_core8.AbstractApiRequest {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteCustomerBusinessProfileInputSchema;
+  outputSchema = deleteCustomerBusinessProfileResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerBusinessProfileId;
+  constructor(customerBusinessProfileId) {
+    super();
+    this.customerBusinessProfileId = customerBusinessProfileId;
+  }
+  getPath() {
+    return `/customers/business_profiles/${this.customerBusinessProfileId}`;
+  }
+};
+
+// src/requests/customer-business-profiles/GetCustomerBusinessProfileDetails.ts
+var import_sdk_js_core9 = require("@deliverart/sdk-js-core");
+var import_zod8 = require("zod");
+var getCustomerBusinessProfileDetailsInputSchema = import_zod8.z.undefined();
+var getCustomerBusinessProfileDetailsResponseSchema = customerBusinessProfileDetailsSchema;
+var GetCustomerBusinessProfileDetails = class extends import_sdk_js_core9.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCustomerBusinessProfileDetailsInputSchema;
+  outputSchema = getCustomerBusinessProfileDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerBusinessProfileId;
+  constructor(customerBusinessProfileId) {
+    super();
+    this.customerBusinessProfileId = customerBusinessProfileId;
+  }
+  getPath() {
+    return `/customers/business_profiles/${this.customerBusinessProfileId}`;
+  }
+};
+
+// src/requests/customer-business-profiles/GetCustomerBusinessProfiles.ts
+var import_sdk_js_core10 = require("@deliverart/sdk-js-core");
+var import_sdk_js_global_types4 = require("@deliverart/sdk-js-global-types");
+var import_zod9 = require("zod");
+var getCustomerBusinessProfilesQuerySchema = import_zod9.z.object({
+  "order[businessName]": import_sdk_js_global_types4.sortDirSchema.optional(),
+  "order[createdAt]": import_sdk_js_global_types4.sortDirSchema.optional(),
+  "order[updatedAt]": import_sdk_js_global_types4.sortDirSchema.optional(),
+  businessName: import_zod9.z.string().optional(),
+  vat: import_zod9.z.string().optional(),
+  taxCode: import_zod9.z.string().optional(),
+  page: import_zod9.z.coerce.number().optional()
+}).merge(import_sdk_js_global_types4.timestampsFilterSchema);
+var getCustomerBusinessProfilesResponseSchema = (0, import_sdk_js_global_types4.createPaginatedSchema)(
+  customerBusinessProfileSchema
+);
+var getCustomerBusinessProfilesInputSchema = import_zod9.z.undefined();
+var GetCustomerBusinessProfiles = class extends import_sdk_js_core10.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCustomerBusinessProfilesInputSchema;
+  outputSchema = getCustomerBusinessProfilesResponseSchema;
+  querySchema = getCustomerBusinessProfilesQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/customers/business_profiles";
+  }
+  parseResponse(data, rawResponse) {
+    const customerBusinessProfiles = import_zod9.z.array(customerBusinessProfileSchema).parse(data);
+    return this.validateOutput({
+      data: customerBusinessProfiles,
+      pagination: (0, import_sdk_js_global_types4.responseToPagination)(rawResponse)
+    });
+  }
+};
+
+// src/requests/customer-business-profiles/GetCustomerBusinessProfilesForCustomer.ts
+var import_sdk_js_core11 = require("@deliverart/sdk-js-core");
+var import_sdk_js_global_types5 = require("@deliverart/sdk-js-global-types");
+var import_zod10 = require("zod");
+var getCustomerBusinessProfilesForCustomerQuerySchema = import_zod10.z.object({
+  "order[businessName]": import_sdk_js_global_types5.sortDirSchema.optional(),
+  "order[createdAt]": import_sdk_js_global_types5.sortDirSchema.optional(),
+  "order[updatedAt]": import_sdk_js_global_types5.sortDirSchema.optional(),
+  businessName: import_zod10.z.string().optional(),
+  vat: import_zod10.z.string().optional(),
+  taxCode: import_zod10.z.string().optional()
+}).merge(import_sdk_js_global_types5.timestampsFilterSchema);
+var getCustomerBusinessProfilesForCustomerResponseSchema = import_zod10.z.array(
+  customerBusinessProfileSchema
+);
+var getCustomerBusinessProfilesForCustomerInputSchema = import_zod10.z.undefined();
+var GetCustomerBusinessProfilesForCustomer = class extends import_sdk_js_core11.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCustomerBusinessProfilesForCustomerInputSchema;
+  outputSchema = getCustomerBusinessProfilesForCustomerResponseSchema;
+  querySchema = getCustomerBusinessProfilesForCustomerQuerySchema;
+  headersSchema = void 0;
+  customerId;
+  constructor(customerId, options) {
+    super(void 0, options);
+    this.customerId = customerId;
+  }
+  getPath() {
+    return `/customers/${this.customerId}/business_profiles`;
+  }
+  parseResponse(data) {
+    return import_zod10.z.array(customerBusinessProfileSchema).parse(data);
+  }
+};
+
+// src/requests/customer-business-profiles/UpdateCustomerBusinessProfile.ts
+var import_sdk_js_core12 = require("@deliverart/sdk-js-core");
+var updateCustomerBusinessProfileInputSchema = writableCustomerBusinessProfileSchema.partial();
+var updateCustomerBusinessProfileResponseSchema = customerBusinessProfileDetailsSchema;
+var UpdateCustomerBusinessProfile = class extends import_sdk_js_core12.AbstractApiRequest {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateCustomerBusinessProfileInputSchema;
+  outputSchema = updateCustomerBusinessProfileResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerId;
+  constructor(customerId, input) {
+    super(input);
+    this.customerId = customerId;
+  }
+  getPath() {
+    return `/customers/business_profiles/${this.customerId}`;
+  }
+};
+
+// src/requests/customers/CreateCustomer.ts
+var import_sdk_js_core13 = require("@deliverart/sdk-js-core");
+var createCustomerInputSchema = writableCreateCustomerSchema.required();
+var createCustomerResponseSchema = customerDetailsSchema;
+var CreateCustomer = class extends import_sdk_js_core13.AbstractApiRequest {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createCustomerInputSchema;
+  outputSchema = createCustomerResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/customers";
+  }
+};
+
+// src/requests/customers/DeleteCustomer.ts
+var import_sdk_js_core14 = require("@deliverart/sdk-js-core");
+var import_zod11 = require("zod");
+var deleteCustomerInputSchema = import_zod11.z.undefined();
+var deleteCustomerResponseSchema = import_zod11.z.undefined();
+var DeleteCustomer = class extends import_sdk_js_core14.AbstractApiRequest {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteCustomerInputSchema;
+  outputSchema = deleteCustomerResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerId;
+  constructor(customerId) {
+    super();
+    this.customerId = customerId;
+  }
+  getPath() {
+    return `/customers/${this.customerId}`;
+  }
+};
+
+// src/requests/customers/GetCustomerDetails.ts
+var import_sdk_js_core15 = require("@deliverart/sdk-js-core");
+var import_zod12 = require("zod");
+var getCustomerDetailsInputSchema = import_zod12.z.undefined();
+var getCustomerDetailsResponseSchema = customerDetailsSchema;
+var GetCustomerDetails = class extends import_sdk_js_core15.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCustomerDetailsInputSchema;
+  outputSchema = getCustomerDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerId;
+  constructor(customerId) {
+    super();
+    this.customerId = customerId;
+  }
+  getPath() {
+    return `/customers/${this.customerId}`;
+  }
+};
+
+// src/requests/customers/GetCustomers.ts
+var import_sdk_js_core16 = require("@deliverart/sdk-js-core");
+var import_sdk_js_global_types6 = require("@deliverart/sdk-js-global-types");
+var import_zod13 = require("zod");
+var getCustomersQuerySchema = import_zod13.z.object({
+  firstName: import_zod13.z.string().optional(),
+  lastName: import_zod13.z.string().optional(),
+  email: import_zod13.z.string().optional(),
+  phoneNumber: import_zod13.z.string().optional(),
+  hasBusinessProfiles: import_zod13.z.coerce.boolean().optional(),
+  hasAddresses: import_zod13.z.coerce.boolean().optional(),
+  "ordersPlaced[between]": import_zod13.z.coerce.number().optional(),
+  "ordersPlaced[gt]": import_zod13.z.coerce.number().optional(),
+  "ordersPlaced[gte]": import_zod13.z.coerce.number().optional(),
+  "ordersPlaced[lt]": import_zod13.z.coerce.number().optional(),
+  "ordersPlaced[lte]": import_zod13.z.coerce.number().optional(),
+  "totalSpent[between]": import_zod13.z.coerce.number().optional(),
+  "totalSpent[gt]": import_zod13.z.coerce.number().optional(),
+  "totalSpent[gte]": import_zod13.z.coerce.number().optional(),
+  "totalSpent[lt]": import_zod13.z.coerce.number().optional(),
+  "totalSpent[lte]": import_zod13.z.coerce.number().optional(),
+  "order[firstName]": import_sdk_js_global_types6.sortDirSchema.optional(),
+  "order[lastName]": import_sdk_js_global_types6.sortDirSchema.optional(),
+  "order[createdAt]": import_sdk_js_global_types6.sortDirSchema.optional(),
+  "order[updatedAt]": import_sdk_js_global_types6.sortDirSchema.optional(),
+  page: import_zod13.z.coerce.number().optional()
+}).merge(import_sdk_js_global_types6.timestampsFilterSchema);
+var getCustomersResponseSchema = (0, import_sdk_js_global_types6.createPaginatedSchema)(customerSchema);
+var getCustomersInputSchema = import_zod13.z.undefined();
+var GetCustomers = class extends import_sdk_js_core16.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCustomersInputSchema;
+  outputSchema = getCustomersResponseSchema;
+  querySchema = getCustomersQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/customers";
+  }
+  parseResponse(data, rawResponse) {
+    const customers = import_zod13.z.array(customerSchema).parse(data);
+    return this.validateOutput({ data: customers, pagination: (0, import_sdk_js_global_types6.responseToPagination)(rawResponse) });
+  }
+};
+
+// src/requests/customers/UpdateCustomer.ts
+var import_sdk_js_core17 = require("@deliverart/sdk-js-core");
+var updateCustomerInputSchema = writableCustomerSchema.partial();
+var updateCustomerResponseSchema = customerDetailsSchema;
+var UpdateCustomer = class extends import_sdk_js_core17.AbstractApiRequest {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateCustomerInputSchema;
+  outputSchema = updateCustomerResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  customerId;
+  constructor(customerId, input) {
+    super(input);
+    this.customerId = customerId;
+  }
+  getPath() {
+    return `/customers/${this.customerId}`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateCustomer,
+  CreateCustomerAddress,
+  CreateCustomerBusinessProfile,
+  DeleteCustomer,
+  DeleteCustomerAddress,
+  DeleteCustomerBusinessProfile,
+  GetCustomerAddressDetails,
+  GetCustomerAddresses,
+  GetCustomerAddressesForCustomer,
+  GetCustomerBusinessProfileDetails,
+  GetCustomerBusinessProfiles,
+  GetCustomerBusinessProfilesForCustomer,
+  GetCustomerDetails,
+  GetCustomers,
+  UpdateCustomer,
+  UpdateCustomerAddress,
+  UpdateCustomerBusinessProfile,
+  createCustomerAddressInputSchema,
+  createCustomerAddressResponseSchema,
+  createCustomerBusinessProfileInputSchema,
+  createCustomerBusinessProfileResponseSchema,
+  createCustomerInputSchema,
+  createCustomerResponseSchema,
+  customerAddressDetailsSchema,
+  customerAddressNullablePathSchema,
+  customerAddressPathSchema,
+  customerAddressSchema,
+  customerBusinessProfileDetailsSchema,
+  customerBusinessProfileNullablePathSchema,
+  customerBusinessProfilePathSchema,
+  customerBusinessProfileSchema,
+  customerDetailsSchema,
+  customerNullablePathSchema,
+  customerPathSchema,
+  customerSchema,
+  deleteCustomerAddressInputSchema,
+  deleteCustomerAddressResponseSchema,
+  deleteCustomerBusinessProfileInputSchema,
+  deleteCustomerBusinessProfileResponseSchema,
+  deleteCustomerInputSchema,
+  deleteCustomerResponseSchema,
+  getCustomerAddressDetailsInputSchema,
+  getCustomerAddressDetailsResponseSchema,
+  getCustomerAddressesForCustomerInputSchema,
+  getCustomerAddressesForCustomerQuerySchema,
+  getCustomerAddressesForCustomerResponseSchema,
+  getCustomerAddressesInputSchema,
+  getCustomerAddressesQuerySchema,
+  getCustomerAddressesResponseSchema,
+  getCustomerBusinessProfileDetailsInputSchema,
+  getCustomerBusinessProfileDetailsResponseSchema,
+  getCustomerBusinessProfilesForCustomerInputSchema,
+  getCustomerBusinessProfilesForCustomerQuerySchema,
+  getCustomerBusinessProfilesForCustomerResponseSchema,
+  getCustomerBusinessProfilesInputSchema,
+  getCustomerBusinessProfilesQuerySchema,
+  getCustomerBusinessProfilesResponseSchema,
+  getCustomerDetailsInputSchema,
+  getCustomerDetailsResponseSchema,
+  getCustomersInputSchema,
+  getCustomersQuerySchema,
+  getCustomersResponseSchema,
+  updateCustomerAddressInputSchema,
+  updateCustomerAddressResponseSchema,
+  updateCustomerBusinessProfileInputSchema,
+  updateCustomerBusinessProfileResponseSchema,
+  updateCustomerInputSchema,
+  updateCustomerResponseSchema,
+  writableCreateCustomerAddressSchema,
+  writableCreateCustomerBusinessProfileSchema,
+  writableCreateCustomerSchema,
+  writableCustomerAddressSchema,
+  writableCustomerBusinessProfileSchema,
+  writableCustomerSchema
+});