@deliverart/sdk-js-point-of-sale 0.0.1

package/dist/index.js

@@ -0,0 +1,251 @@
+// src/models.ts
+import { addressSchema, datetimeSchema, dayOfWeekSchema } from "@deliverart/sdk-js-global-types";
+import { z as z2 } from "zod";
+
+// src/types.ts
+import { z } from "zod";
+var pointOfSaleOpeningStatuses = ["OPEN", "CLOSED"];
+var pointOfSaleOpeningStatusSchema = z.enum(pointOfSaleOpeningStatuses);
+var pointOfSaleCapabilities = ["DELIVERY_OPTIMIZATION"];
+var pointOfSaleCapabilitySchema = z.enum(pointOfSaleCapabilities);
+var pointOfSaleUserRoles = ["ROLE_ADMIN", "ROLE_READER"];
+var pointOfSaleUserRoleSchema = z.enum(pointOfSaleUserRoles);
+
+// src/models.ts
+var timeSettingSchema = z2.object({
+  dayOfWeek: dayOfWeekSchema,
+  times: z2.object({
+    startTime: z2.string().regex(/^\d{2}:\d{2}$/),
+    endTime: z2.string().regex(/^\d{2}:\d{2}$/)
+  }).array()
+});
+var deliveryTimeSettingSchema = z2.object({
+  dayOfWeek: dayOfWeekSchema,
+  times: z2.object({
+    startTime: z2.string().regex(/^\d{2}:\d{2}$/),
+    endTime: z2.string().regex(/^\d{2}:\d{2}$/),
+    availableCouriers: z2.number().nonnegative()
+  }).array()
+});
+var pointOfSaleSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  address: addressSchema,
+  timezone: z2.string(),
+  location: z2.object({
+    latitude: z2.number(),
+    longitude: z2.number()
+  }),
+  capabilities: pointOfSaleCapabilitySchema.array(),
+  openingStatus: pointOfSaleOpeningStatusSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema
+});
+var userPointOfSaleSchema = z2.object({
+  pointOfSale: pointOfSaleSchema,
+  role: pointOfSaleUserRoleSchema
+});
+var pointOfSaleIntervalValues = [5, 10, 15, 20, 30, 60];
+var pointOfSaleAutoAcceptOrderValues = [0, 5, 10, 15];
+var pointOfSaleDetailsSchema = pointOfSaleSchema.extend({
+  company: z2.string().regex(
+    /^\/companies\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/
+  ),
+  settings: z2.object({
+    menuLocales: z2.any().array(),
+    deliveryTimesInterval: z2.number().positive().refine((value) => pointOfSaleIntervalValues.includes(value)),
+    takeAwayTimesInterval: z2.number().positive().refine((value) => pointOfSaleIntervalValues.includes(value)),
+    numberMinutesToPrecessFirstOrder: z2.number().positive(),
+    numberMinutesTimeChangeTolerance: z2.number().positive(),
+    maxCountableItemsPerBundle: z2.number().positive(),
+    maxOrdersPerBundle: z2.number().positive(),
+    preventOrderTakingIfTheMaxCountableItemsExceeded: z2.boolean(),
+    numberMinutesBeforeAutoAcceptOrder: z2.number().nonnegative().refine((value) => pointOfSaleAutoAcceptOrderValues.includes(value))
+  }),
+  openingTimeSettings: timeSettingSchema.array(),
+  deliveryTimeSettings: deliveryTimeSettingSchema.array(),
+  takeAwayTimeSettings: timeSettingSchema.array(),
+  numberOfCouriers: z2.number().nonnegative()
+});
+var writablePointOfSaleSchema = pointOfSaleDetailsSchema.pick({
+  name: true,
+  address: true,
+  timezone: true,
+  settings: true,
+  openingTimeSettings: true,
+  deliveryTimeSettings: true,
+  takeAwayTimeSettings: true,
+  capabilities: true,
+  openingStatus: true
+});
+var writableCreatePointOfSaleSchema = z2.object({
+  ...writablePointOfSaleSchema.shape,
+  ...pointOfSaleDetailsSchema.pick({
+    company: true
+  }).shape
+});
+
+// src/requests/CreatePointOfSale.ts
+import { AbstractApiRequest } from "@deliverart/sdk-js-core";
+var createPointOfSaleInputSchema = writableCreatePointOfSaleSchema.required();
+var createPointOfSaleResponseSchema = pointOfSaleDetailsSchema;
+var CreatePointOfSale = class extends AbstractApiRequest {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createPointOfSaleInputSchema;
+  outputSchema = createPointOfSaleResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/point_of_sales";
+  }
+};
+
+// src/requests/DeletePointOfSale.ts
+import { AbstractApiRequest as AbstractApiRequest2 } from "@deliverart/sdk-js-core";
+import { z as z3 } from "zod";
+var deletePointOfSaleInputSchema = z3.undefined();
+var deletePointOfSaleResponseSchema = z3.undefined();
+var DeletePointOfSale = class extends AbstractApiRequest2 {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deletePointOfSaleInputSchema;
+  outputSchema = deletePointOfSaleResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  pointOfSaleId;
+  constructor(pointOfSaleId) {
+    super();
+    this.pointOfSaleId = pointOfSaleId;
+  }
+  getPath() {
+    return `/point_of_sales/${this.pointOfSaleId}`;
+  }
+};
+
+// src/requests/GetPointOfSaleDetails.ts
+import { AbstractApiRequest as AbstractApiRequest3 } from "@deliverart/sdk-js-core";
+import { z as z4 } from "zod";
+var getPointOfSaleDetailsInputSchema = z4.undefined();
+var getPointOfSaleDetailsResponseSchema = pointOfSaleDetailsSchema;
+var GetPointOfSaleDetails = class extends AbstractApiRequest3 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getPointOfSaleDetailsInputSchema;
+  outputSchema = getPointOfSaleDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  pointOfSaleId;
+  constructor(pointOfSaleId) {
+    super();
+    this.pointOfSaleId = pointOfSaleId;
+  }
+  getPath() {
+    return `/point_of_sales/${this.pointOfSaleId}`;
+  }
+};
+
+// src/requests/GetPointOfSales.ts
+import { AbstractApiRequest as AbstractApiRequest4 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema,
+  responseToPagination,
+  sortDirSchema
+} from "@deliverart/sdk-js-global-types";
+import { z as z5 } from "zod";
+var getCompaniesQuerySchema = z5.object({
+  name: z5.string().optional(),
+  openingStatus: pointOfSaleOpeningStatusSchema.optional(),
+  "integrationActivationRequests.connectionId": z5.string().optional(),
+  "address.city": z5.string().optional(),
+  "address.postalCode": z5.string().optional(),
+  "order[name]": sortDirSchema.optional(),
+  "order[createdAt]": sortDirSchema.optional(),
+  "order[updatedAt]": sortDirSchema.optional(),
+  page: z5.coerce.number().optional()
+});
+var getCompaniesResponseSchema = createPaginatedSchema(pointOfSaleSchema);
+var getCompaniesInputSchema = z5.undefined();
+var GetPointOfSales = class extends AbstractApiRequest4 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCompaniesInputSchema;
+  outputSchema = getCompaniesResponseSchema;
+  querySchema = getCompaniesQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/point_of_sales";
+  }
+  parseResponse(data, rawResponse) {
+    const pointOfSales = z5.array(pointOfSaleSchema).parse(data);
+    return this.validateOutput({
+      data: pointOfSales,
+      pagination: responseToPagination(rawResponse)
+    });
+  }
+};
+
+// src/requests/UpdatePointOfSale.ts
+import { AbstractApiRequest as AbstractApiRequest5 } from "@deliverart/sdk-js-core";
+var updatePointOfSaleInputSchema = writablePointOfSaleSchema.partial();
+var updatePointOfSaleResponseSchema = pointOfSaleDetailsSchema;
+var UpdatePointOfSale = class extends AbstractApiRequest5 {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updatePointOfSaleInputSchema;
+  outputSchema = updatePointOfSaleResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  pointOfSaleId;
+  constructor(pointOfSaleId, input) {
+    super(input);
+    this.pointOfSaleId = pointOfSaleId;
+  }
+  getPath() {
+    return `/point_of_sales/${this.pointOfSaleId}`;
+  }
+};
+export {
+  CreatePointOfSale,
+  DeletePointOfSale,
+  GetPointOfSaleDetails,
+  GetPointOfSales,
+  UpdatePointOfSale,
+  createPointOfSaleInputSchema,
+  createPointOfSaleResponseSchema,
+  deletePointOfSaleInputSchema,
+  deletePointOfSaleResponseSchema,
+  deliveryTimeSettingSchema,
+  getCompaniesInputSchema,
+  getCompaniesQuerySchema,
+  getCompaniesResponseSchema,
+  getPointOfSaleDetailsInputSchema,
+  getPointOfSaleDetailsResponseSchema,
+  pointOfSaleAutoAcceptOrderValues,
+  pointOfSaleCapabilities,
+  pointOfSaleCapabilitySchema,
+  pointOfSaleDetailsSchema,
+  pointOfSaleIntervalValues,
+  pointOfSaleOpeningStatusSchema,
+  pointOfSaleOpeningStatuses,
+  pointOfSaleSchema,
+  pointOfSaleUserRoleSchema,
+  pointOfSaleUserRoles,
+  timeSettingSchema,
+  updatePointOfSaleInputSchema,
+  updatePointOfSaleResponseSchema,
+  userPointOfSaleSchema,
+  writableCreatePointOfSaleSchema,
+  writablePointOfSaleSchema
+};

package/eslint.config.js

@@ -0,0 +1,41 @@
+/* eslint-disable */
+// eslint.config.js per @typescript-eslint v8
+import js from '@eslint/js'
+import prettier from 'eslint-config-prettier'
+import simpleImportSortPlugin from 'eslint-plugin-simple-import-sort'
+import tsPlugin from '@typescript-eslint/eslint-plugin'
+import tsParser from '@typescript-eslint/parser'
+
+export default [
+  js.configs.recommended,
+  {
+    files: ['**/*.ts'],
+    languageOptions: {
+      parser: tsParser,
+      globals: {
+        process: 'readonly',
+        fetch: 'readonly',
+        Request: 'readonly',
+        Response: 'readonly',
+        Headers: 'readonly',
+      },
+      parserOptions: {
+        project: ['./tsconfig.json'],
+        tsconfigRootDir: process.cwd(),
+        sourceType: 'module',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin,
+      'simple-import-sort': simpleImportSortPlugin,
+    },
+    rules: {
+      'simple-import-sort/imports': 'error',
+      'simple-import-sort/exports': 'error',
+      '@typescript-eslint/no-unused-vars': 'warn',
+    },
+  },
+  prettier,
+]
+
+export const ignores = ['dist', 'node_modules']

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@deliverart/sdk-js-point-of-sale",
+  "description": "Deliverart JavaScript SDK for Point of Sale Management",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "zod": "3.25.67",
+    "axios": "1.9.0",
+    "@deliverart/sdk-js-core": "0.1.3",
+    "@deliverart/sdk-js-global-types": "0.0.12"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.4",
+    "@eslint/js": "9.28.0",
+    "@types/node": "22.15.30",
+    "@typescript-eslint/eslint-plugin": "8.33.1",
+    "@typescript-eslint/parser": "8.33.1",
+    "eslint": "9.28.0",
+    "eslint-config-prettier": "10.1.5",
+    "eslint-plugin-simple-import-sort": "12.1.1",
+    "prettier": "3.5.3",
+    "tsup": "8.5.0",
+    "typescript": "5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs",
+    "dev": "tsup src/index.ts --dts --watch",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "prettier": "prettier --check .",
+    "prettier:fix": "prettier --write .",
+    "version": "@changesets/cli version",
+    "release": "@changesets/cli publish"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './models'
+export * from './requests'
+export * from './types'

package/src/models.ts

@@ -0,0 +1,110 @@
+import { addressSchema, datetimeSchema, dayOfWeekSchema } from '@deliverart/sdk-js-global-types'
+import { z } from 'zod'
+
+import {
+  pointOfSaleCapabilitySchema,
+  pointOfSaleOpeningStatusSchema,
+  pointOfSaleUserRoleSchema,
+} from './types'
+
+export const timeSettingSchema = z.object({
+  dayOfWeek: dayOfWeekSchema,
+  times: z
+    .object({
+      startTime: z.string().regex(/^\d{2}:\d{2}$/),
+      endTime: z.string().regex(/^\d{2}:\d{2}$/),
+    })
+    .array(),
+})
+export type TimeSetting = z.infer<typeof timeSettingSchema>
+
+export const deliveryTimeSettingSchema = z.object({
+  dayOfWeek: dayOfWeekSchema,
+  times: z
+    .object({
+      startTime: z.string().regex(/^\d{2}:\d{2}$/),
+      endTime: z.string().regex(/^\d{2}:\d{2}$/),
+      availableCouriers: z.number().nonnegative(),
+    })
+    .array(),
+})
+export type DeliveryTimeSetting = z.infer<typeof deliveryTimeSettingSchema>
+
+export const pointOfSaleSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  address: addressSchema,
+  timezone: z.string(),
+  location: z.object({
+    latitude: z.number(),
+    longitude: z.number(),
+  }),
+  capabilities: pointOfSaleCapabilitySchema.array(),
+  openingStatus: pointOfSaleOpeningStatusSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+})
+export type PointOfSale = z.infer<typeof pointOfSaleSchema>
+
+export const userPointOfSaleSchema = z.object({
+  pointOfSale: pointOfSaleSchema,
+  role: pointOfSaleUserRoleSchema,
+})
+export type UserPointOfSale = z.infer<typeof userPointOfSaleSchema>
+
+export const pointOfSaleIntervalValues = [5, 10, 15, 20, 30, 60]
+export const pointOfSaleAutoAcceptOrderValues = [0, 5, 10, 15]
+
+export const pointOfSaleDetailsSchema = pointOfSaleSchema.extend({
+  company: z
+    .string()
+    .regex(
+      /^\/companies\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+    ),
+  settings: z.object({
+    menuLocales: z.any().array(),
+    deliveryTimesInterval: z
+      .number()
+      .positive()
+      .refine(value => pointOfSaleIntervalValues.includes(value)),
+    takeAwayTimesInterval: z
+      .number()
+      .positive()
+      .refine(value => pointOfSaleIntervalValues.includes(value)),
+    numberMinutesToPrecessFirstOrder: z.number().positive(),
+    numberMinutesTimeChangeTolerance: z.number().positive(),
+    maxCountableItemsPerBundle: z.number().positive(),
+    maxOrdersPerBundle: z.number().positive(),
+    preventOrderTakingIfTheMaxCountableItemsExceeded: z.boolean(),
+    numberMinutesBeforeAutoAcceptOrder: z
+      .number()
+      .nonnegative()
+      .refine(value => pointOfSaleAutoAcceptOrderValues.includes(value)),
+  }),
+  openingTimeSettings: timeSettingSchema.array(),
+  deliveryTimeSettings: deliveryTimeSettingSchema.array(),
+  takeAwayTimeSettings: timeSettingSchema.array(),
+  numberOfCouriers: z.number().nonnegative(),
+})
+export type PointOfSaleDetails = z.infer<typeof pointOfSaleDetailsSchema>
+
+export const writablePointOfSaleSchema = pointOfSaleDetailsSchema.pick({
+  name: true,
+  address: true,
+  timezone: true,
+  settings: true,
+  openingTimeSettings: true,
+  deliveryTimeSettings: true,
+  takeAwayTimeSettings: true,
+  capabilities: true,
+  openingStatus: true,
+})
+export type WritablePointOfSale = z.infer<typeof writablePointOfSaleSchema>
+
+export const writableCreatePointOfSaleSchema = z.object({
+  ...writablePointOfSaleSchema.shape,
+  ...pointOfSaleDetailsSchema.pick({
+    company: true,
+  }).shape,
+})
+export type WritableCreatePointOfSale = z.infer<typeof writableCreatePointOfSaleSchema>

package/src/requests/CreatePointOfSale.ts

@@ -0,0 +1,36 @@
+import { AbstractApiRequest } from '@deliverart/sdk-js-core'
+import { z } from 'zod'
+
+import {
+  PointOfSaleDetails,
+  pointOfSaleDetailsSchema,
+  writableCreatePointOfSaleSchema,
+} from '../models'
+
+export const createPointOfSaleInputSchema = writableCreatePointOfSaleSchema.required()
+export type CreatePointOfSaleInput = z.infer<typeof createPointOfSaleInputSchema>
+
+export const createPointOfSaleResponseSchema = pointOfSaleDetailsSchema
+export type CreatePointOfSaleResponse = PointOfSaleDetails
+
+export class CreatePointOfSale extends AbstractApiRequest<
+  CreatePointOfSaleInput,
+  CreatePointOfSaleResponse
+> {
+  readonly method = 'POST'
+  readonly contentType = 'application/json'
+  readonly accept = 'application/json'
+
+  readonly inputSchema = createPointOfSaleInputSchema
+  readonly outputSchema = createPointOfSaleResponseSchema
+  readonly querySchema = undefined
+  readonly headersSchema = undefined
+
+  constructor(input: CreatePointOfSaleInput) {
+    super(input)
+  }
+
+  getPath(): string {
+    return '/point_of_sales'
+  }
+}

package/src/requests/DeletePointOfSale.ts

@@ -0,0 +1,27 @@
+import { AbstractApiRequest } from '@deliverart/sdk-js-core'
+import { z } from 'zod'
+
+export const deletePointOfSaleInputSchema = z.undefined()
+export const deletePointOfSaleResponseSchema = z.undefined()
+
+export class DeletePointOfSale extends AbstractApiRequest<void, void> {
+  readonly method = 'DELETE'
+  readonly contentType = 'application/json'
+  readonly accept = 'application/json'
+
+  readonly inputSchema = deletePointOfSaleInputSchema
+  readonly outputSchema = deletePointOfSaleResponseSchema
+  readonly querySchema = undefined
+  readonly headersSchema = undefined
+
+  private readonly pointOfSaleId: string
+
+  constructor(pointOfSaleId: string) {
+    super()
+    this.pointOfSaleId = pointOfSaleId
+  }
+
+  getPath(): string {
+    return `/point_of_sales/${this.pointOfSaleId}`
+  }
+}

package/src/requests/GetPointOfSaleDetails.ts

@@ -0,0 +1,30 @@
+import { AbstractApiRequest } from '@deliverart/sdk-js-core'
+import { z } from 'zod'
+
+import { PointOfSaleDetails, pointOfSaleDetailsSchema } from '../models'
+
+export const getPointOfSaleDetailsInputSchema = z.undefined()
+
+export const getPointOfSaleDetailsResponseSchema = pointOfSaleDetailsSchema
+export type GetPointOfSaleDetailsResponse = PointOfSaleDetails
+
+export class GetPointOfSaleDetails extends AbstractApiRequest<void, GetPointOfSaleDetailsResponse> {
+  readonly method = 'GET'
+  readonly contentType = 'application/json'
+  readonly accept = 'application/json'
+  readonly inputSchema = getPointOfSaleDetailsInputSchema
+  readonly outputSchema = getPointOfSaleDetailsResponseSchema
+  readonly querySchema = undefined
+  readonly headersSchema = undefined
+
+  private readonly pointOfSaleId: string
+
+  constructor(pointOfSaleId: string) {
+    super()
+    this.pointOfSaleId = pointOfSaleId
+  }
+
+  getPath(): string {
+    return `/point_of_sales/${this.pointOfSaleId}`
+  }
+}

package/src/requests/GetPointOfSales.ts

@@ -0,0 +1,61 @@
+import { AbstractApiRequest } from '@deliverart/sdk-js-core'
+import {
+  createPaginatedSchema,
+  Paginated,
+  responseToPagination,
+  sortDirSchema,
+} from '@deliverart/sdk-js-global-types'
+import { AxiosResponse } from 'axios'
+import { z } from 'zod'
+
+import { PointOfSale, pointOfSaleSchema } from '../models'
+import { pointOfSaleOpeningStatusSchema } from '../types'
+
+export const getCompaniesQuerySchema = z.object({
+  name: z.string().optional(),
+  openingStatus: pointOfSaleOpeningStatusSchema.optional(),
+  'integrationActivationRequests.connectionId': z.string().optional(),
+  'address.city': z.string().optional(),
+  'address.postalCode': z.string().optional(),
+  'order[name]': sortDirSchema.optional(),
+  'order[createdAt]': sortDirSchema.optional(),
+  'order[updatedAt]': sortDirSchema.optional(),
+  page: z.coerce.number().optional(),
+})
+export type GetCompaniesQueryParams = z.infer<typeof getCompaniesQuerySchema>
+
+export const getCompaniesResponseSchema = createPaginatedSchema(pointOfSaleSchema)
+export type GetCompaniesResponse = z.infer<typeof getCompaniesResponseSchema>
+
+export const getCompaniesInputSchema = z.undefined()
+
+export class GetPointOfSales extends AbstractApiRequest<
+  void,
+  GetCompaniesResponse,
+  GetCompaniesQueryParams
+> {
+  readonly method = 'GET'
+  readonly contentType = 'application/json'
+  readonly accept = 'application/json'
+
+  readonly inputSchema = getCompaniesInputSchema
+  readonly outputSchema = getCompaniesResponseSchema
+  readonly querySchema = getCompaniesQuerySchema
+  readonly headersSchema = undefined
+
+  constructor(options?: { query?: GetCompaniesQueryParams }) {
+    super(undefined, options)
+  }
+
+  getPath(): string {
+    return '/point_of_sales'
+  }
+
+  parseResponse(data: unknown, rawResponse: AxiosResponse): Paginated<PointOfSale> {
+    const pointOfSales = z.array(pointOfSaleSchema).parse(data)
+    return this.validateOutput({
+      data: pointOfSales,
+      pagination: responseToPagination(rawResponse),
+    })
+  }
+}

package/src/requests/UpdatePointOfSale.ts

@@ -0,0 +1,35 @@
+import { AbstractApiRequest } from '@deliverart/sdk-js-core'
+import { z } from 'zod'
+
+import { PointOfSaleDetails, pointOfSaleDetailsSchema, writablePointOfSaleSchema } from '../models'
+
+export const updatePointOfSaleInputSchema = writablePointOfSaleSchema.partial()
+export type UpdatePointOfSaleInput = z.infer<typeof updatePointOfSaleInputSchema>
+
+export const updatePointOfSaleResponseSchema = pointOfSaleDetailsSchema
+export type UpdatePointOfSaleResponse = PointOfSaleDetails
+
+export class UpdatePointOfSale extends AbstractApiRequest<
+  UpdatePointOfSaleInput,
+  UpdatePointOfSaleResponse
+> {
+  readonly method = 'PATCH'
+  readonly contentType = 'application/merge-patch+json'
+  readonly accept = 'application/json'
+
+  readonly inputSchema = updatePointOfSaleInputSchema
+  readonly outputSchema = updatePointOfSaleResponseSchema
+  readonly querySchema = undefined
+  readonly headersSchema = undefined
+
+  private readonly pointOfSaleId: string
+
+  constructor(pointOfSaleId: string, input: UpdatePointOfSaleInput) {
+    super(input)
+    this.pointOfSaleId = pointOfSaleId
+  }
+
+  getPath(): string {
+    return `/point_of_sales/${this.pointOfSaleId}`
+  }
+}

package/src/requests/index.ts

@@ -0,0 +1,5 @@
+export * from './CreatePointOfSale'
+export * from './DeletePointOfSale'
+export * from './GetPointOfSaleDetails'
+export * from './GetPointOfSales'
+export * from './UpdatePointOfSale'

package/src/types.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+export const pointOfSaleOpeningStatuses = ['OPEN', 'CLOSED'] as const
+export const pointOfSaleOpeningStatusSchema = z.enum(pointOfSaleOpeningStatuses)
+export type PointOfSaleOpeningStatus = z.infer<typeof pointOfSaleOpeningStatusSchema>
+
+export const pointOfSaleCapabilities = ['DELIVERY_OPTIMIZATION'] as const
+export const pointOfSaleCapabilitySchema = z.enum(pointOfSaleCapabilities)
+export type PointOfSaleCapability = z.infer<typeof pointOfSaleCapabilitySchema>
+
+export const pointOfSaleUserRoles = ['ROLE_ADMIN', 'ROLE_READER'] as const
+export const pointOfSaleUserRoleSchema = z.enum(pointOfSaleUserRoles)
+export type PointOfSaleUserRole = z.infer<typeof pointOfSaleUserRoleSchema>

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src"]
+}