@deliverart/sdk-js-integration 0.0.1

package/dist/index.js

@@ -0,0 +1,3385 @@
+// src/activatable-integration.ts
+import { datetimeSchema } from "@deliverart/sdk-js-global-types";
+import { z as z4 } from "zod";
+
+// src/activatable-integration-data-schemas.ts
+import { z as z2 } from "zod";
+
+// src/types.ts
+import { z } from "zod";
+var integrationStatuses = ["pending", "active", "deleting"];
+var integrationStatusSchema = z.enum(integrationStatuses);
+var integrationProviders = ["deliverart", "cassa_in_cloud"];
+var integrationProviderSchema = z.enum(integrationProviders);
+var integrationServices = ["deliveroo", "justeat", "glovo", "cassa_in_cloud"];
+var integrationServiceSchema = z.enum(integrationServices);
+var integrationClientLogRequestMethods = ["DELETE", "GET", "PATCH", "POST", "PUT"];
+var integrationClientLogRequestMethodSchema = z.enum(integrationClientLogRequestMethods);
+var integrationJustEatSyncTypes = ["ALL", "DELIVERY", "TAKE_AWAY"];
+var integrationJustEatSyncTypeSchema = z.enum(integrationJustEatSyncTypes);
+var integrationJustEatRestaurantStatuses = ["OPEN", "CLOSED"];
+var integrationJustEatRestaurantStatusSchema = z.enum(integrationJustEatRestaurantStatuses);
+var integrationDeliverooSiteStatuses = ["OPEN", "CLOSED"];
+var integrationDeliverooSiteStatusSchema = z.enum(integrationDeliverooSiteStatuses);
+var integrationDeliverooSyncMenuProcessModes = ["menu", "item_availabilities"];
+var integrationDeliverooSyncMenuProcessModeSchema = z.enum(
+  integrationDeliverooSyncMenuProcessModes
+);
+var integrationDeliverooWebhookEventTypes = [
+  "order.new",
+  "order.status_update",
+  "rider.status_update",
+  "menu.upload_result"
+];
+var integrationDeliverooWebhookEventTypeSchema = z.enum(
+  integrationDeliverooWebhookEventTypes
+);
+var integrationGlovoMenuUpdateStatuses = [
+  "SUCCESS",
+  "PROCESSING",
+  "FETCH_MENU_INVALID_PAYLOAD",
+  "FETCH_MENU_SERVER_ERROR",
+  "FETCH_MENU_UNAUTHORIZED",
+  "NOT_PROCESSED",
+  "LIMIT_EXCEEDED",
+  "GLOVO_ERROR",
+  "SCHEDULE_CATALOG_DISABLED"
+];
+var integrationGlovoMenuUpdateStatusSchema = z.enum(integrationGlovoMenuUpdateStatuses);
+var integrationGlovoStoreStatuses = ["OPEN", "CLOSED"];
+var integrationGlovoStoreStatusSchema = z.enum(integrationGlovoStoreStatuses);
+var integrationGlovoWebhookEventTypes = ["order.dispatched", "order.cancelled"];
+var integrationGlovoWebhookEventTypeSchema = z.enum(integrationGlovoWebhookEventTypes);
+var integrationCassaInCloudDirections = [
+  "EXTERNAL_TO_INTERNAL",
+  "INTERNAL_TO_EXTERNAL"
+];
+var integrationCassaInCloudDirectionSchema = z.enum(integrationCassaInCloudDirections);
+var integrationCassaInCloudProductChannels = [
+  "RISTO",
+  "SALE",
+  "ECOMMERCE",
+  "MOBILE_COMMERCE",
+  "SELF_ORDER",
+  "KIOSK"
+];
+var integrationCassaInCloudProductChannelSchema = z.enum(
+  integrationCassaInCloudProductChannels
+);
+var integrationCassaInCloudWebHookEventEntities = [
+  "BILL",
+  "RECEIPT",
+  "CREDIT_NOTE",
+  "INVOICE",
+  "DDT",
+  "ORDER",
+  "QUOTATION",
+  "RECONCILIATION",
+  "STOCK_MOVEMENT",
+  "CUSTOMER",
+  "ORGANIZATION"
+];
+var integrationCassaInCloudWebHookEventEntitySchema = z.enum(
+  integrationCassaInCloudWebHookEventEntities
+);
+var integrationCassaInCloudWebHookEventEvents = ["CREATE", "UPDATE", "DELETE"];
+var integrationCassaInCloudWebHookEventEventSchema = z.enum(
+  integrationCassaInCloudWebHookEventEvents
+);
+function createIntegrationPathSchemas(service) {
+  const regex = new RegExp(`^/integrations/${service}/[a-z_]+/[0-9a-fA-F-]{36}$`);
+  const pathSchema = z.string().refine((val) => regex.test(val), {
+    message: `Invalid integration ${service} path format`
+  });
+  const nullablePathSchema = z.string().nullable().refine((val) => val == null || regex.test(val), {
+    message: `Invalid integration ${service} path format`
+  });
+  return { pathSchema, nullablePathSchema };
+}
+var integrationPathSchemas = Object.fromEntries(
+  integrationServices.map((service) => [service, createIntegrationPathSchemas(service)])
+);
+var integrationDeliverooPathSchema = integrationPathSchemas.deliveroo.pathSchema;
+var integrationDeliverooNullablePathSchema = integrationPathSchemas.deliveroo.nullablePathSchema;
+var integrationGlovoPathSchema = integrationPathSchemas.glovo.pathSchema;
+var integrationGlovoNullablePathSchema = integrationPathSchemas.glovo.nullablePathSchema;
+var integrationJustEatPathSchema = integrationPathSchemas.justeat.pathSchema;
+var integrationJustEatNullablePathSchema = integrationPathSchemas.justeat.nullablePathSchema;
+var integrationCassaInCloudPathSchema = integrationPathSchemas.cassa_in_cloud.pathSchema;
+var integrationCassaInCloudNullablePathSchema = integrationPathSchemas.cassa_in_cloud.nullablePathSchema;
+var integrationPathSchema = z.string().refine((val) => /^\/integrations\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val), {
+  message: "Invalid integration path format"
+});
+var integrationNullablePathSchema = z.string().nullable().refine((val) => val == null || /^\/integrations\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val), {
+  message: "Invalid integration path format"
+});
+var integrationCassaInCloudSyncMenuErrorLogPathSchema = z.string().refine(
+  (val) => /^\/integrations\/cassa_in_cloud\/[a-z_]+\/[0-9a-fA-F-]{36}\/sync_menu_processes\/[a-z_]+\/[0-9a-fA-F-]{36}\/error_logs\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(
+    val
+  ),
+  {
+    message: "Invalid integration path format"
+  }
+);
+var integrationCassaInCloudSyncMenuErrorLogNullablePathSchema = z.string().nullable().refine(
+  (val) => val == null || /^\/integrations\/cassa_in_cloud\/[a-z_]+\/[0-9a-fA-F-]{36}\/sync_menu_processes\/[a-z_]+\/[0-9a-fA-F-]{36}\/error_logs\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(
+    val
+  ),
+  {
+    message: "Invalid integration path format"
+  }
+);
+
+// src/activatable-integration-data-schemas.ts
+var integrationDeliverooDataSchema = z2.object({
+  brandId: z2.string(),
+  siteId: z2.string(),
+  salesModeId: z2.string().nullable()
+});
+var integrationGlovoDataSchema = z2.object({
+  storeId: z2.string(),
+  salesModeId: z2.string().nullable()
+});
+var integrationJustEatDataSchema = z2.object({
+  restaurantId: z2.string(),
+  salesModeId: z2.string().nullable()
+});
+var integrationCassaInCloudDataSchema = z2.object({
+  apiKey: z2.string(),
+  idSalesPoint: z2.number(),
+  direction: integrationCassaInCloudDirectionSchema,
+  locale: z2.string()
+});
+var integrationServiceDataSchema = z2.discriminatedUnion("service", [
+  z2.object({
+    service: z2.literal("deliveroo"),
+    data: integrationDeliverooDataSchema
+  }),
+  z2.object({
+    service: z2.literal("glovo"),
+    data: integrationGlovoDataSchema
+  }),
+  z2.object({
+    service: z2.literal("justeat"),
+    data: integrationJustEatDataSchema
+  }),
+  z2.object({
+    service: z2.literal("cassa_in_cloud"),
+    data: integrationCassaInCloudDataSchema
+  })
+]);
+
+// src/activatable-integration-types.ts
+import { z as z3 } from "zod";
+var activatableIntegrationStatuses = [
+  "waiting_for_user",
+  "waiting_for_admin",
+  "request_sent_partner",
+  "active",
+  "failed"
+];
+var activatableIntegrationStatusSchema = z3.enum(activatableIntegrationStatuses);
+var activatableIntegrationHealthStatuses = ["success", "waiting", "error"];
+var activatableIntegrationHealthStatusSchema = z3.enum(activatableIntegrationHealthStatuses);
+
+// src/activatable-integration.ts
+var activatableIntegrationBaseSchema = z4.object({
+  id: z4.string(),
+  connectionId: z4.string().nullable(),
+  integration: z4.union([
+    integrationDeliverooPathSchema,
+    integrationGlovoPathSchema,
+    integrationJustEatPathSchema,
+    integrationCassaInCloudPathSchema
+  ]).nullable(),
+  status: activatableIntegrationStatusSchema,
+  healthStatus: activatableIntegrationHealthStatusSchema,
+  provider: integrationProviderSchema,
+  name: z4.string(),
+  message: z4.string().nullable(),
+  internalNotes: z4.string().nullable(),
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  updates: z4.array(
+    z4.object({
+      status: activatableIntegrationStatusSchema,
+      message: z4.string(),
+      updatedAt: datetimeSchema
+    })
+  )
+});
+function createIntegrationSchema(service, dataSchema, integrationPathSchema2) {
+  return z4.object({
+    service: z4.literal(service),
+    data: dataSchema,
+    integration: integrationPathSchema2.nullable()
+  }).merge(activatableIntegrationBaseSchema.omit({ integration: true }));
+}
+var activatableIntegrationSchema = z4.discriminatedUnion("service", [
+  createIntegrationSchema(
+    "deliveroo",
+    integrationDeliverooDataSchema,
+    integrationDeliverooNullablePathSchema
+  ),
+  createIntegrationSchema("glovo", integrationGlovoDataSchema, integrationGlovoNullablePathSchema),
+  createIntegrationSchema(
+    "justeat",
+    integrationJustEatDataSchema,
+    integrationJustEatNullablePathSchema
+  ),
+  createIntegrationSchema(
+    "cassa_in_cloud",
+    integrationCassaInCloudDataSchema,
+    integrationCassaInCloudNullablePathSchema
+  )
+]);
+
+// src/activation-request.ts
+import { pointOfSaleSchema } from "@deliverart/sdk-js-point-of-sale";
+import { z as z5 } from "zod";
+var integrationActivationRequestSchema = activatableIntegrationSchema;
+var integrationActivationRequestDetailsSchema = z5.discriminatedUnion("service", [
+  z5.object({
+    pointOfSale: pointOfSaleSchema,
+    service: z5.literal("deliveroo"),
+    data: integrationDeliverooDataSchema
+  }).merge(activatableIntegrationBaseSchema),
+  z5.object({
+    pointOfSale: pointOfSaleSchema,
+    service: z5.literal("glovo"),
+    data: integrationGlovoDataSchema
+  }).merge(activatableIntegrationBaseSchema),
+  z5.object({
+    pointOfSale: pointOfSaleSchema,
+    service: z5.literal("justeat"),
+    data: integrationJustEatDataSchema
+  }).merge(activatableIntegrationBaseSchema),
+  z5.object({
+    pointOfSale: pointOfSaleSchema,
+    service: z5.literal("cassa_in_cloud"),
+    data: integrationCassaInCloudDataSchema
+  }).merge(activatableIntegrationBaseSchema)
+]);
+
+// src/cancellation-request.ts
+import { datetimeSchema as datetimeSchema2 } from "@deliverart/sdk-js-global-types";
+import { z as z7 } from "zod";
+
+// src/cancellation-request-types.ts
+import { z as z6 } from "zod";
+var integrationCancellationRequestStatuses = ["pending", "aborted", "completed"];
+var integrationCancellationRequestStatusSchema = z6.enum(
+  integrationCancellationRequestStatuses
+);
+var integrationCancellationRequestPathSchema = z6.string().refine((val) => /^\/integrations\/cancellation_requests\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val), {
+  message: "Invalid integration cancellation request path format"
+});
+var integrationCancellationRequestNullablePathSchema = z6.string().nullable().refine(
+  (val) => {
+    if (!val) return true;
+    return /^\/integrations\/cancellation_requests\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val);
+  },
+  {
+    message: "Invalid integration cancellation request path format"
+  }
+);
+
+// src/cancellation-request.ts
+var integrationCancellationRequestSchema = z7.object({
+  id: z7.string(),
+  status: integrationCancellationRequestStatusSchema,
+  createdAt: datetimeSchema2,
+  updatedAt: datetimeSchema2
+});
+var integrationCancellationRequestDetailsSchema = integrationCancellationRequestSchema.extend({
+  integration: integrationNullablePathSchema
+});
+
+// src/requests/activation-requests/ActivateIntegrationActivationRequest.ts
+import { AbstractApiRequest } from "@deliverart/sdk-js-core";
+import { z as z8 } from "zod";
+var activateIntegrationActivationRequestInputSchema = z8.undefined();
+var activateIntegrationActivationRequestResponseSchema = integrationActivationRequestDetailsSchema;
+var ActivateIntegrationActivationRequest = class extends AbstractApiRequest {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = activateIntegrationActivationRequestInputSchema;
+  outputSchema = activateIntegrationActivationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationActivationRequestId;
+  constructor(integrationActivationRequestId) {
+    super();
+    this.integrationActivationRequestId = integrationActivationRequestId;
+  }
+  getPath() {
+    return `/integrations/activation_requests/${this.integrationActivationRequestId}/send-partner`;
+  }
+};
+
+// src/requests/activation-requests/AnnotateIntegrationActivationRequest.ts
+import { AbstractApiRequest as AbstractApiRequest2 } from "@deliverart/sdk-js-core";
+import { z as z9 } from "zod";
+var annotateIntegrationActivationRequestInputSchema = z9.object({
+  message: z9.string().min(1, "Message is required")
+});
+var annotateIntegrationActivationRequestResponseSchema = integrationActivationRequestDetailsSchema;
+var AnnotateIntegrationActivationRequest = class extends AbstractApiRequest2 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = annotateIntegrationActivationRequestInputSchema;
+  outputSchema = annotateIntegrationActivationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationActivationRequestId;
+  constructor(integrationActivationRequestId, input) {
+    super(input);
+    this.integrationActivationRequestId = integrationActivationRequestId;
+  }
+  getPath() {
+    return `/integrations/activation_requests/${this.integrationActivationRequestId}/annotate`;
+  }
+};
+
+// src/requests/activation-requests/CreateIntegrationActivationRequest.ts
+import { AbstractApiRequest as AbstractApiRequest3 } from "@deliverart/sdk-js-core";
+import { pointOfSalePathSchema } from "@deliverart/sdk-js-point-of-sale";
+import { z as z10 } from "zod";
+var writableIntegrationActivationRequestBaseSchema = z10.object({
+  name: z10.string(),
+  provider: integrationProviderSchema,
+  pointOfSale: pointOfSalePathSchema
+});
+var createIntegrationActivationRequestInputSchema = z10.discriminatedUnion("service", [
+  z10.object({
+    service: z10.literal("deliveroo"),
+    data: integrationDeliverooDataSchema
+  }).merge(writableIntegrationActivationRequestBaseSchema),
+  z10.object({
+    service: z10.literal("glovo"),
+    data: integrationGlovoDataSchema
+  }).merge(writableIntegrationActivationRequestBaseSchema),
+  z10.object({
+    service: z10.literal("justeat"),
+    data: integrationJustEatDataSchema
+  }).merge(writableIntegrationActivationRequestBaseSchema),
+  z10.object({
+    service: z10.literal("cassa_in_cloud"),
+    data: integrationCassaInCloudDataSchema
+  }).merge(writableIntegrationActivationRequestBaseSchema)
+]);
+var createIntegrationActivationRequestResponseSchema = integrationActivationRequestDetailsSchema;
+var CreateIntegrationActivationRequest = class extends AbstractApiRequest3 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createIntegrationActivationRequestInputSchema;
+  outputSchema = createIntegrationActivationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/integrations/activation_requests";
+  }
+};
+
+// src/requests/activation-requests/DeleteIntegrationActivationRequest.ts
+import { AbstractApiRequest as AbstractApiRequest4 } from "@deliverart/sdk-js-core";
+import { z as z11 } from "zod";
+var deleteIntegrationActivationRequestInputSchema = z11.undefined();
+var deleteIntegrationActivationRequestResponseSchema = z11.undefined();
+var DeleteIntegrationActivationRequest = class extends AbstractApiRequest4 {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteIntegrationActivationRequestInputSchema;
+  outputSchema = deleteIntegrationActivationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationActivationRequestId;
+  constructor(integrationActivationRequestId) {
+    super();
+    this.integrationActivationRequestId = integrationActivationRequestId;
+  }
+  getPath() {
+    return `/integrations/activation_requests/${this.integrationActivationRequestId}`;
+  }
+};
+
+// src/requests/activation-requests/GetIntegrationActivationRequestDetails.ts
+import { AbstractApiRequest as AbstractApiRequest5 } from "@deliverart/sdk-js-core";
+import { z as z12 } from "zod";
+var getIntegrationActivationRequestDetailsInputSchema = z12.undefined();
+var getIntegrationActivationRequestDetailsResponseSchema = integrationActivationRequestDetailsSchema;
+var GetIntegrationActivationRequestDetails = class extends AbstractApiRequest5 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationActivationRequestDetailsInputSchema;
+  outputSchema = getIntegrationActivationRequestDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationActivationRequestId;
+  constructor(integrationActivationRequestId) {
+    super();
+    this.integrationActivationRequestId = integrationActivationRequestId;
+  }
+  getPath() {
+    return `/integrations/activation_requests/${this.integrationActivationRequestId}`;
+  }
+};
+
+// src/requests/activation-requests/GetIntegrationActivationRequests.ts
+import { AbstractApiRequest as AbstractApiRequest6 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema,
+  responseToPagination,
+  sortDirSchema,
+  timestampsFilterSchema
+} from "@deliverart/sdk-js-global-types";
+import { z as z13 } from "zod";
+var getIntegrationActivationRequestsQuerySchema = z13.object({
+  "order[service]": sortDirSchema.optional(),
+  "order[status]": sortDirSchema.optional(),
+  "order[createdAt]": sortDirSchema.optional(),
+  "order[updatedAt]": sortDirSchema.optional(),
+  service: integrationServiceSchema.optional(),
+  "service[]": z13.array(integrationServiceSchema).optional(),
+  provider: integrationProviderSchema.optional(),
+  "provider[]": z13.array(integrationProviderSchema).optional(),
+  status: activatableIntegrationStatusSchema.optional(),
+  "status[]": z13.array(activatableIntegrationStatusSchema).optional(),
+  healthStatus: activatableIntegrationHealthStatusSchema.optional(),
+  "healthStatus[]": z13.array(activatableIntegrationHealthStatusSchema).optional(),
+  connectionId: z13.string().optional(),
+  "connectionId[]": z13.array(z13.string()).optional(),
+  page: z13.coerce.number().optional()
+}).merge(timestampsFilterSchema);
+var getIntegrationActivationRequestsResponseSchema = createPaginatedSchema(
+  integrationActivationRequestSchema
+);
+var getIntegrationActivationRequestsInputSchema = z13.undefined();
+var GetIntegrationActivationRequests = class extends AbstractApiRequest6 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationActivationRequestsInputSchema;
+  outputSchema = getIntegrationActivationRequestsResponseSchema;
+  querySchema = getIntegrationActivationRequestsQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/integrations/activation_requests";
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z13.array(integrationActivationRequestSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination(rawResponse)
+    });
+  }
+};
+
+// src/requests/activation-requests/RespondIntegrationActivationRequest.ts
+import { AbstractApiRequest as AbstractApiRequest7 } from "@deliverart/sdk-js-core";
+import { z as z14 } from "zod";
+var respondIntegrationActivationRequestInputSchema = z14.object({
+  message: z14.string().min(1, "Message is required"),
+  data: z14.union([
+    integrationDeliverooDataSchema,
+    integrationGlovoDataSchema,
+    integrationJustEatDataSchema,
+    integrationCassaInCloudDataSchema
+  ])
+});
+var respondIntegrationActivationRequestResponseSchema = integrationActivationRequestDetailsSchema;
+var RespondIntegrationActivationRequest = class extends AbstractApiRequest7 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = respondIntegrationActivationRequestInputSchema;
+  outputSchema = respondIntegrationActivationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationActivationRequestId;
+  constructor(integrationActivationRequestId, input) {
+    super(input);
+    this.integrationActivationRequestId = integrationActivationRequestId;
+  }
+  getPath() {
+    return `/integrations/activation_requests/${this.integrationActivationRequestId}/respond`;
+  }
+};
+
+// src/requests/activation-requests/SendIntegrationActivationRequestToPartner.ts
+import { AbstractApiRequest as AbstractApiRequest8 } from "@deliverart/sdk-js-core";
+import { z as z15 } from "zod";
+var sendIntegrationActivationRequestToPartnerInputSchema = z15.undefined();
+var sendIntegrationActivationRequestToPartnerResponseSchema = integrationActivationRequestDetailsSchema;
+var SendIntegrationActivationRequestToPartner = class extends AbstractApiRequest8 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = sendIntegrationActivationRequestToPartnerInputSchema;
+  outputSchema = sendIntegrationActivationRequestToPartnerResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationActivationRequestId;
+  constructor(integrationActivationRequestId) {
+    super();
+    this.integrationActivationRequestId = integrationActivationRequestId;
+  }
+  getPath() {
+    return `/integrations/activation_requests/${this.integrationActivationRequestId}/send-partner`;
+  }
+};
+
+// src/requests/activation-requests/UpdateIntegrationActivationRequest.ts
+import { AbstractApiRequest as AbstractApiRequest9 } from "@deliverart/sdk-js-core";
+import { pointOfSalePathSchema as pointOfSalePathSchema2 } from "@deliverart/sdk-js-point-of-sale";
+import { z as z16 } from "zod";
+var writableIntegrationActivationRequestBaseSchema2 = z16.object({
+  healthStatus: activatableIntegrationHealthStatusSchema,
+  provider: integrationProviderSchema,
+  pointOfSale: pointOfSalePathSchema2,
+  name: z16.string(),
+  internalNotes: z16.string().nullable()
+}).partial();
+var updateIntegrationActivationRequestInputSchema = z16.discriminatedUnion("service", [
+  z16.object({
+    service: z16.literal("deliveroo"),
+    data: integrationDeliverooDataSchema.optional()
+  }).merge(writableIntegrationActivationRequestBaseSchema2),
+  z16.object({
+    service: z16.literal("glovo"),
+    data: integrationGlovoDataSchema.optional()
+  }).merge(writableIntegrationActivationRequestBaseSchema2),
+  z16.object({
+    service: z16.literal("justeat"),
+    data: integrationJustEatDataSchema.optional()
+  }).merge(writableIntegrationActivationRequestBaseSchema2),
+  z16.object({
+    service: z16.literal("cassa_in_cloud"),
+    data: integrationCassaInCloudDataSchema.optional()
+  }).merge(writableIntegrationActivationRequestBaseSchema2)
+]);
+var updateIntegrationActivationRequestResponseSchema = integrationActivationRequestDetailsSchema;
+var UpdateIntegrationActivationRequest = class extends AbstractApiRequest9 {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateIntegrationActivationRequestInputSchema;
+  outputSchema = updateIntegrationActivationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationActivationRequestId;
+  constructor(integrationActivationRequestId, input) {
+    super(input);
+    this.integrationActivationRequestId = integrationActivationRequestId;
+  }
+  getPath() {
+    return `/integrations/activation_requests/${this.integrationActivationRequestId}`;
+  }
+};
+
+// src/requests/cancellation-requests/CancelIntegrationCancellationRequest.ts
+import { AbstractApiRequest as AbstractApiRequest10 } from "@deliverart/sdk-js-core";
+import { z as z17 } from "zod";
+var cancelIntegrationCancellationRequestInputSchema = z17.undefined();
+var cancelIntegrationCancellationRequestResponseSchema = integrationCancellationRequestDetailsSchema;
+var CancelIntegrationCancellationRequest = class extends AbstractApiRequest10 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = cancelIntegrationCancellationRequestInputSchema;
+  outputSchema = cancelIntegrationCancellationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCancellationRequestId;
+  constructor(integrationCancellationRequestId) {
+    super();
+    this.integrationCancellationRequestId = integrationCancellationRequestId;
+  }
+  getPath() {
+    return `/integrations/cancellation_requests/${this.integrationCancellationRequestId}/cancel`;
+  }
+};
+
+// src/requests/cancellation-requests/CreateIntegrationCancellationRequest.ts
+import { AbstractApiRequest as AbstractApiRequest11 } from "@deliverart/sdk-js-core";
+import { z as z18 } from "zod";
+var createIntegrationCancellationRequestInputSchema = z18.object({
+  integration: integrationPathSchema
+});
+var createIntegrationCancellationRequestResponseSchema = integrationCancellationRequestDetailsSchema;
+var CreateIntegrationCancellationRequest = class extends AbstractApiRequest11 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createIntegrationCancellationRequestInputSchema;
+  outputSchema = createIntegrationCancellationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/integrations/cancellation_requests";
+  }
+};
+
+// src/requests/cancellation-requests/DeleteIntegrationCancellationRequest.ts
+import { AbstractApiRequest as AbstractApiRequest12 } from "@deliverart/sdk-js-core";
+import { z as z19 } from "zod";
+var deleteIntegrationCancellationRequestInputSchema = z19.undefined();
+var deleteIntegrationCancellationRequestResponseSchema = z19.undefined();
+var DeleteIntegrationCancellationRequest = class extends AbstractApiRequest12 {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteIntegrationCancellationRequestInputSchema;
+  outputSchema = deleteIntegrationCancellationRequestResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCancellationRequestId;
+  constructor(integrationCancellationRequestId) {
+    super();
+    this.integrationCancellationRequestId = integrationCancellationRequestId;
+  }
+  getPath() {
+    return `/integrations/cancellation_requests/${this.integrationCancellationRequestId}`;
+  }
+};
+
+// src/requests/cancellation-requests/GetIntegrationCancellationRequestDetails.ts
+import { AbstractApiRequest as AbstractApiRequest13 } from "@deliverart/sdk-js-core";
+import { z as z20 } from "zod";
+var getIntegrationCancellationRequestDetailsInputSchema = z20.undefined();
+var getIntegrationCancellationRequestDetailsResponseSchema = integrationCancellationRequestDetailsSchema;
+var GetIntegrationCancellationRequestDetails = class extends AbstractApiRequest13 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCancellationRequestDetailsInputSchema;
+  outputSchema = getIntegrationCancellationRequestDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCancellationRequestId;
+  constructor(integrationCancellationRequestId) {
+    super();
+    this.integrationCancellationRequestId = integrationCancellationRequestId;
+  }
+  getPath() {
+    return `/integrations/cancellation_requests/${this.integrationCancellationRequestId}`;
+  }
+};
+
+// src/requests/cancellation-requests/GetIntegrationCancellationRequests.ts
+import { AbstractApiRequest as AbstractApiRequest14 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema2,
+  responseToPagination as responseToPagination2,
+  sortDirSchema as sortDirSchema2,
+  timestampsFilterSchema as timestampsFilterSchema2
+} from "@deliverart/sdk-js-global-types";
+import { z as z21 } from "zod";
+var getIntegrationCancellationRequestsQuerySchema = z21.object({
+  "order[createdAt]": sortDirSchema2.optional(),
+  "order[updatedAt]": sortDirSchema2.optional(),
+  status: integrationCancellationRequestStatusSchema.optional(),
+  "status[]": z21.array(integrationCancellationRequestStatusSchema).optional(),
+  page: z21.coerce.number().optional()
+}).merge(timestampsFilterSchema2);
+var getIntegrationCancellationRequestsResponseSchema = createPaginatedSchema2(
+  integrationCancellationRequestSchema
+);
+var getIntegrationCancellationRequestsInputSchema = z21.undefined();
+var GetIntegrationCancellationRequests = class extends AbstractApiRequest14 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCancellationRequestsInputSchema;
+  outputSchema = getIntegrationCancellationRequestsResponseSchema;
+  querySchema = getIntegrationCancellationRequestsQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/integrations/cancellation_requests";
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z21.array(integrationCancellationRequestSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination2(rawResponse)
+    });
+  }
+};
+
+// src/requests/DeleteIntegration.ts
+import { AbstractApiRequest as AbstractApiRequest15 } from "@deliverart/sdk-js-core";
+import { z as z22 } from "zod";
+var deleteIntegrationInputSchema = z22.undefined();
+var deleteIntegrationResponseSchema = z22.undefined();
+var DeleteIntegration = class extends AbstractApiRequest15 {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteIntegrationInputSchema;
+  outputSchema = deleteIntegrationResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationId;
+  constructor(integrationId) {
+    super();
+    this.integrationId = integrationId;
+  }
+  getPath() {
+    return `/integrations/${this.integrationId}`;
+  }
+};
+
+// src/requests/GetIntegrationDetails.ts
+import { AbstractApiRequest as AbstractApiRequest16 } from "@deliverart/sdk-js-core";
+import { z as z29 } from "zod";
+
+// src/integration-schemas.ts
+import { z as z28 } from "zod";
+
+// src/service-schemas/cassa_in_cloud.ts
+import {
+  datetimeSchema as datetimeSchema4,
+  sortDirSchema as sortDirSchema4,
+  timestampsFilterSchema as timestampsFilterSchema3
+} from "@deliverart/sdk-js-global-types";
+import { z as z24 } from "zod";
+
+// src/schemas.ts
+import { datetimeSchema as datetimeSchema3, sortDirSchema as sortDirSchema3 } from "@deliverart/sdk-js-global-types";
+import { pointOfSalePathSchema as pointOfSalePathSchema3 } from "@deliverart/sdk-js-point-of-sale";
+import { salesModeNullablePathSchema } from "@deliverart/sdk-js-sales-mode";
+import { z as z23 } from "zod";
+var menuVersionSchema = z23.object({
+  id: z23.string(),
+  contentUrl: z23.string(),
+  filePath: z23.string(),
+  createdAt: datetimeSchema3,
+  updatedAt: datetimeSchema3
+});
+var menuVersionDetailsSchema = menuVersionSchema.extend({
+  integration: integrationPathSchema
+});
+var integrationBaseSchema = z23.object({
+  id: z23.string(),
+  cancellationRequest: integrationCancellationRequestNullablePathSchema,
+  connectionId: z23.string().nullable(),
+  service: integrationServiceSchema,
+  status: integrationStatusSchema,
+  provider: integrationProviderSchema,
+  createdAt: datetimeSchema3,
+  updatedAt: datetimeSchema3
+});
+var writableIntegrationSchema = integrationBaseSchema.pick({
+  status: true,
+  // Only for ADMIN users
+  provider: true
+});
+var integrationDetailsFieldsSchema = z23.object({
+  pointOfSale: pointOfSalePathSchema3
+});
+var integrationDeliveryProviderCommonSchema = z23.object({
+  name: z23.string(),
+  skipInvalidItem: z23.boolean(),
+  skipNegativePrices: z23.boolean(),
+  importTaggedItems: z23.boolean(),
+  tagsForImport: z23.array(z23.string()).optional(),
+  isValidMenu: z23.boolean(),
+  latestMenuSyncAt: datetimeSchema3,
+  latestMenuCheckAt: datetimeSchema3,
+  currentMenuVersion: menuVersionSchema.nullable(),
+  salesMode: salesModeNullablePathSchema
+});
+var integrationClientLogRequestSchema = z23.object({
+  id: z23.string(),
+  url: z23.string(),
+  method: integrationClientLogRequestMethodSchema,
+  statusCode: z23.number(),
+  createdAt: datetimeSchema3
+});
+var integrationClientLogRequestDetailsSchema = integrationClientLogRequestSchema.extend({
+  integration: integrationPathSchema,
+  requestHeaders: z23.record(z23.string()),
+  responseHeaders: z23.record(z23.string()),
+  requestBody: z23.string(),
+  responseBody: z23.string()
+});
+var clientLogRequestQuerySchema = z23.object({
+  "order[createdAt]": sortDirSchema3.optional(),
+  method: integrationClientLogRequestMethodSchema.optional(),
+  "method[]": z23.array(integrationClientLogRequestMethodSchema).optional(),
+  "statusCode[between]": z23.number().optional(),
+  "statusCode[gt]": z23.number().optional(),
+  "statusCode[gte]": z23.number().optional(),
+  "statusCode[lt]": z23.number().optional(),
+  "statusCode[lte]": z23.number().optional(),
+  "createdAt[before]": z23.string().optional(),
+  "createdAt[strictly_before]": z23.string().optional(),
+  "createdAt[after]": z23.string().optional(),
+  "createdAt[strictly_after]": z23.string().optional(),
+  page: z23.coerce.number().optional()
+});
+
+// src/service-schemas/cassa_in_cloud.ts
+var integrationCassaInCloudSchema = integrationBaseSchema.omit({ service: true }).extend({
+  finalized: z24.boolean(),
+  apiKey: z24.string(),
+  service: integrationServiceSchema.extract(["cassa_in_cloud"]),
+  idSalesPoint: z24.number().nonnegative(),
+  direction: integrationCassaInCloudDirectionSchema,
+  locale: z24.string(),
+  latestMenuSyncAt: datetimeSchema4.nullable(),
+  defaultCustomerId: z24.string().nullable(),
+  skipSyncProductDescription: z24.boolean(),
+  productChannels: integrationCassaInCloudProductChannelSchema.array()
+});
+var integrationCassaInCloudDetailsSchema = integrationCassaInCloudSchema.extend(
+  integrationDetailsFieldsSchema.shape
+);
+var integrationsCassaInCloudQuerySchema = z24.object({
+  "order[createdAt]": sortDirSchema4.optional(),
+  "order[updatedAt]": sortDirSchema4.optional(),
+  "order[latestMenuSyncAt]": sortDirSchema4.optional(),
+  apiKey: z24.string().optional(),
+  "apiKey[]": z24.array(z24.string()).optional(),
+  idSalesPoint: z24.string().optional(),
+  "idSalesPoint[]": z24.array(z24.string()).optional(),
+  direction: integrationCassaInCloudDirectionSchema.optional(),
+  "direction[]": z24.array(integrationCassaInCloudDirectionSchema).optional(),
+  status: integrationStatusSchema.optional(),
+  "status[]": z24.array(integrationStatusSchema).optional(),
+  connectionId: z24.string().optional(),
+  "connectionId[]": z24.array(z24.string()).optional(),
+  finalized: z24.coerce.boolean().optional(),
+  skipInvalidItem: z24.coerce.boolean().optional(),
+  isValidMenu: z24.coerce.boolean().optional(),
+  "latestMenuSyncAt[before]": z24.string().optional(),
+  "latestMenuSyncAt[strictly_before]": z24.string().optional(),
+  "latestMenuSyncAt[after]": z24.string().optional(),
+  "latestMenuSyncAt[strictly_after]": z24.string().optional(),
+  service: integrationServiceSchema.extract(["cassa_in_cloud"]).optional(),
+  page: z24.coerce.number().optional()
+}).merge(timestampsFilterSchema3);
+var integrationCassaInCloudEditableFieldsSchema = integrationCassaInCloudSchema.pick({
+  apiKey: true,
+  idSalesPoint: true,
+  direction: true,
+  skipSyncProductDescription: true,
+  productChannels: true,
+  locale: true,
+  provider: true
+  // Available for only ADMIN users
+}).partial();
+var integrationCassaInCloudSyncMenuProcessSchema = z24.object({
+  id: z24.string(),
+  currentPlaces: z24.any(),
+  availableSalesModesIds: z24.array(z24.string()),
+  availableProductIds: z24.array(z24.string()),
+  availableCategoryIds: z24.array(z24.string()),
+  createdAt: datetimeSchema4,
+  endAt: datetimeSchema4.nullable()
+});
+var integrationCassaInCloudSyncMenuProcessDetailsSchema = integrationCassaInCloudSyncMenuProcessSchema.extend({
+  integration: integrationCassaInCloudPathSchema,
+  errors: z24.array(integrationCassaInCloudSyncMenuErrorLogPathSchema).optional()
+});
+var integrationCassaInCloudSyncMenuProcessesQuerySchema = z24.object({
+  "order[createdAt]": sortDirSchema4.optional(),
+  "order[endAt]": sortDirSchema4.optional(),
+  "createdAt[before]": z24.string().optional(),
+  "createdAt[strictly_before]": z24.string().optional(),
+  "createdAt[after]": z24.string().optional(),
+  "createdAt[strictly_after]": z24.string().optional(),
+  "endAt[before]": z24.string().optional(),
+  "endAt[strictly_before]": z24.string().optional(),
+  "endAt[after]": z24.string().optional(),
+  "endAt[strictly_after]": z24.string().optional(),
+  page: z24.coerce.number().optional()
+});
+var integrationCassaInCloudWebHookEventSchema = z24.object({
+  id: z24.string(),
+  entity: integrationCassaInCloudWebHookEventEntitySchema,
+  event: integrationCassaInCloudWebHookEventEventSchema,
+  body: z24.any(),
+  createdAt: datetimeSchema4
+});
+var integrationCassaInCloudWebHookEventDetailsSchema = integrationCassaInCloudWebHookEventSchema.extend({
+  integration: integrationCassaInCloudPathSchema
+});
+var integrationCassaInCloudWebHookEventsQuerySchema = z24.object({
+  "order[createdAt]": sortDirSchema4.optional(),
+  entity: integrationCassaInCloudWebHookEventEntitySchema.optional(),
+  "entity[]": z24.array(integrationCassaInCloudWebHookEventEntitySchema).optional(),
+  event: integrationCassaInCloudWebHookEventEventSchema.optional(),
+  "event[]": z24.array(integrationCassaInCloudWebHookEventEventSchema).optional(),
+  "createdAt[before]": z24.string().optional(),
+  "createdAt[strictly_before]": z24.string().optional(),
+  "createdAt[after]": z24.string().optional(),
+  "createdAt[strictly_after]": z24.string().optional(),
+  page: z24.coerce.number().optional()
+});
+
+// src/service-schemas/deliveroo.ts
+import {
+  datetimeSchema as datetimeSchema5,
+  sortDirSchema as sortDirSchema5,
+  timestampsFilterSchema as timestampsFilterSchema4
+} from "@deliverart/sdk-js-global-types";
+import { z as z25 } from "zod";
+var integrationDeliverooSchema = integrationBaseSchema.omit({ service: true }).extend(integrationDeliveryProviderCommonSchema.shape).extend({
+  brandId: z25.string(),
+  siteId: z25.string(),
+  imageMenuUrl: z25.string().url().nullable(),
+  latestOpeningHoursSyncAt: datetimeSchema5.nullable(),
+  service: integrationServiceSchema.extract(["deliveroo"]),
+  acceptanceTimeout: z25.number().min(0).max(8),
+  nextSyncMenuScheduledAt: datetimeSchema5.nullable()
+});
+var integrationDeliverooDetailsSchema = integrationDeliverooSchema.extend(
+  integrationDetailsFieldsSchema.shape
+);
+var integrationDeliverooEditableFieldsSchema = integrationDeliverooSchema.pick({
+  name: true,
+  brandId: true,
+  siteId: true,
+  imageMenuUrl: true,
+  acceptanceTimeout: true,
+  skipNegativePrices: true,
+  skipInvalidItem: true,
+  salesMode: true,
+  importTaggedItems: true,
+  tagsForImport: true,
+  provider: true
+  // Available for only ADMIN users
+});
+var integrationsDeliverooQuerySchema = z25.object({
+  "order[createdAt]": sortDirSchema5.optional(),
+  "order[updatedAt]": sortDirSchema5.optional(),
+  "order[latestMenuCheckAt]": sortDirSchema5.optional(),
+  "order[latestMenuSyncAt]": sortDirSchema5.optional(),
+  "order[latestOpeningHoursSyncAt]": sortDirSchema5.optional(),
+  name: z25.string().optional(),
+  brandId: z25.string().optional(),
+  "brandId[]": z25.array(z25.string()).optional(),
+  siteId: z25.string().optional(),
+  "siteId[]": z25.array(z25.string()).optional(),
+  status: integrationStatusSchema.optional(),
+  "status[]": z25.array(integrationStatusSchema).optional(),
+  connectionId: z25.string().optional(),
+  "connectionId[]": z25.array(z25.string()).optional(),
+  skipInvalidItem: z25.coerce.boolean().optional(),
+  isValidMenu: z25.coerce.boolean().optional(),
+  "latestMenuCheckAt[before]": z25.string().optional(),
+  "latestMenuCheckAt[strictly_before]": z25.string().optional(),
+  "latestMenuCheckAt[after]": z25.string().optional(),
+  "latestMenuCheckAt[strictly_after]": z25.string().optional(),
+  "latestMenuSyncAt[before]": z25.string().optional(),
+  "latestMenuSyncAt[strictly_before]": z25.string().optional(),
+  "latestMenuSyncAt[after]": z25.string().optional(),
+  "latestMenuSyncAt[strictly_after]": z25.string().optional(),
+  "latestOpeningHoursSyncAt[before]": z25.string().optional(),
+  "latestOpeningHoursSyncAt[strictly_before]": z25.string().optional(),
+  "latestOpeningHoursSyncAt[after]": z25.string().optional(),
+  "latestOpeningHoursSyncAt[strictly_after]": z25.string().optional(),
+  service: integrationServiceSchema.extract(["deliveroo"]).optional(),
+  page: z25.coerce.number().optional()
+}).merge(timestampsFilterSchema4);
+var integrationDeliverooSyncMenuProcessSchema = z25.object({
+  id: z25.string(),
+  mode: integrationDeliverooSyncMenuProcessModeSchema,
+  success: z25.boolean().nullable(),
+  response: z25.string().nullable(),
+  createdAt: datetimeSchema5,
+  endAt: datetimeSchema5.nullable()
+});
+var integrationDeliverooSyncMenuProcessDetailsSchema = integrationDeliverooSyncMenuProcessSchema.extend({
+  integration: integrationDeliverooPathSchema
+});
+var integrationDeliverooSyncMenuProcessesQuerySchema = z25.object({
+  "order[endAt]": sortDirSchema5.optional(),
+  mode: integrationDeliverooSyncMenuProcessModeSchema.optional(),
+  "mode[]": z25.array(integrationDeliverooSyncMenuProcessModeSchema).optional(),
+  "createdAt[before]": z25.string().optional(),
+  "createdAt[strictly_before]": z25.string().optional(),
+  "createdAt[after]": z25.string().optional(),
+  "createdAt[strictly_after]": z25.string().optional(),
+  "endAt[before]": z25.string().optional(),
+  "endAt[strictly_before]": z25.string().optional(),
+  "endAt[after]": z25.string().optional(),
+  "endAt[strictly_after]": z25.string().optional(),
+  page: z25.coerce.number().optional()
+});
+var integrationDeliverooWebhookEventSchema = z25.object({
+  id: z25.string(),
+  event: integrationDeliverooWebhookEventTypeSchema,
+  body: z25.any(),
+  createdAt: datetimeSchema5
+});
+var integrationDeliverooWebhookEventDetailsSchema = integrationDeliverooWebhookEventSchema.extend({
+  integration: integrationDeliverooPathSchema
+});
+var integrationDeliverooWebhookEventsQueryParamsSchema = z25.object({
+  "order[createdAt]": sortDirSchema5.optional(),
+  event: integrationDeliverooWebhookEventTypeSchema.optional(),
+  "event[]": z25.array(integrationDeliverooWebhookEventTypeSchema).optional(),
+  "createdAt[before]": z25.string().optional(),
+  "createdAt[strictly_before]": z25.string().optional(),
+  "createdAt[after]": z25.string().optional(),
+  "createdAt[strictly_after]": z25.string().optional(),
+  page: z25.coerce.number().optional()
+});
+
+// src/service-schemas/glovo.ts
+import {
+  datetimeSchema as datetimeSchema6,
+  sortDirSchema as sortDirSchema6,
+  timestampsFilterSchema as timestampsFilterSchema5
+} from "@deliverart/sdk-js-global-types";
+import { z as z26 } from "zod";
+var integrationGlovoSchema = integrationBaseSchema.omit({ service: true }).extend(integrationDeliveryProviderCommonSchema.shape).extend({
+  storeId: z26.string(),
+  locale: z26.string(),
+  pendingMenuChanges: z26.boolean(),
+  service: integrationServiceSchema.extract(["glovo"])
+});
+var integrationGlovoDetailsSchema = integrationGlovoSchema.extend(
+  integrationDetailsFieldsSchema.shape
+);
+var integrationGlovoEditableFieldsSchema = integrationGlovoSchema.pick({
+  name: true,
+  storeId: true,
+  locale: true,
+  skipNegativePrices: true,
+  skipInvalidItem: true,
+  salesMode: true,
+  importTaggedItems: true,
+  tagsForImport: true,
+  provider: true
+}).partial();
+var integrationsGlovoQuerySchema = z26.object({
+  "order[createdAt]": sortDirSchema6.optional(),
+  "order[updatedAt]": sortDirSchema6.optional(),
+  "order[latestMenuCheckAt]": sortDirSchema6.optional(),
+  "order[latestMenuSyncAt]": sortDirSchema6.optional(),
+  name: z26.string().optional(),
+  storeId: z26.string().optional(),
+  "storeId[]": z26.array(z26.string()).optional(),
+  status: integrationStatusSchema.optional(),
+  "status[]": z26.array(integrationStatusSchema).optional(),
+  connectionId: z26.string().optional(),
+  "connectionId[]": z26.array(z26.string()).optional(),
+  skipInvalidItem: z26.coerce.boolean().optional(),
+  isValidMenu: z26.coerce.boolean().optional(),
+  "latestMenuCheckAt[before]": z26.string().optional(),
+  "latestMenuCheckAt[strictly_before]": z26.string().optional(),
+  "latestMenuCheckAt[after]": z26.string().optional(),
+  "latestMenuCheckAt[strictly_after]": z26.string().optional(),
+  "latestMenuSyncAt[before]": z26.string().optional(),
+  "latestMenuSyncAt[strictly_before]": z26.string().optional(),
+  "latestMenuSyncAt[after]": z26.string().optional(),
+  "latestMenuSyncAt[strictly_after]": z26.string().optional(),
+  service: integrationServiceSchema.extract(["glovo"]).optional(),
+  page: z26.coerce.number().optional()
+}).merge(timestampsFilterSchema5);
+var integrationGlovoWebhookEventSchema = z26.object({
+  id: z26.string(),
+  event: integrationGlovoWebhookEventTypeSchema,
+  body: z26.any(),
+  createdAt: datetimeSchema6
+});
+var integrationGlovoWebhookEventDetailsSchema = integrationGlovoWebhookEventSchema.extend({
+  integration: integrationGlovoPathSchema
+});
+var integrationGlovoWebhookEventsQueryParamsSchema = z26.object({
+  "order[createdAt]": sortDirSchema6.optional(),
+  event: integrationGlovoWebhookEventTypeSchema.optional(),
+  "event[]": z26.array(integrationGlovoWebhookEventTypeSchema).optional(),
+  "createdAt[before]": z26.string().optional(),
+  "createdAt[strictly_before]": z26.string().optional(),
+  "createdAt[after]": z26.string().optional(),
+  "createdAt[strictly_after]": z26.string().optional(),
+  page: z26.coerce.number().optional()
+});
+var integrationGlovoMenuUpdateSchema = z26.object({
+  id: z26.string(),
+  transactionId: z26.string().nullable(),
+  status: integrationGlovoMenuUpdateStatusSchema.nullable(),
+  retryCompleted: z26.boolean(),
+  createdAt: datetimeSchema6,
+  responseAt: datetimeSchema6.nullable(),
+  latestCheckAt: datetimeSchema6.nullable()
+});
+var integrationGlovoMenuUpdateDetailsSchema = integrationGlovoMenuUpdateSchema.extend({
+  integration: integrationDeliverooPathSchema,
+  details: z26.any().nullable()
+});
+var integrationGlovoMenuUpdatesQuerySchema = z26.object({
+  "order[createdAt]": sortDirSchema6.optional(),
+  "order[responseAt]": sortDirSchema6.optional(),
+  "order[latestCheckAt]": sortDirSchema6.optional(),
+  retryCompleted: z26.coerce.boolean().optional(),
+  transactionId: z26.string().optional(),
+  "transactionId[]": z26.array(z26.string()).optional(),
+  status: integrationGlovoMenuUpdateStatusSchema.optional(),
+  "status[]": z26.array(integrationGlovoMenuUpdateStatusSchema).optional(),
+  "createdAt[before]": z26.string().optional(),
+  "createdAt[strictly_before]": z26.string().optional(),
+  "createdAt[after]": z26.string().optional(),
+  "createdAt[strictly_after]": z26.string().optional(),
+  "responseAt[before]": z26.string().optional(),
+  "responseAt[strictly_before]": z26.string().optional(),
+  "responseAt[after]": z26.string().optional(),
+  "responseAt[strictly_after]": z26.string().optional(),
+  "latestCheckAt[before]": z26.string().optional(),
+  "latestCheckAt[strictly_before]": z26.string().optional(),
+  "latestCheckAt[after]": z26.string().optional(),
+  "latestCheckAt[strictly_after]": z26.string().optional(),
+  page: z26.coerce.number().optional()
+});
+
+// src/service-schemas/justeat.ts
+import {
+  datetimeSchema as datetimeSchema7,
+  sortDirSchema as sortDirSchema7,
+  timestampsFilterSchema as timestampsFilterSchema6
+} from "@deliverart/sdk-js-global-types";
+import { z as z27 } from "zod";
+var integrationJustEatSchema = integrationBaseSchema.omit({ service: true }).extend(integrationDeliveryProviderCommonSchema.shape).extend({
+  syncType: integrationJustEatSyncTypeSchema,
+  defaultLanguage: z27.string(),
+  restaurantId: z27.string(),
+  latestOpeningTimesSyncAt: datetimeSchema7,
+  service: integrationServiceSchema.extract(["justeat"]),
+  autoAcceptOrders: z27.boolean(),
+  nextSyncMenuScheduledAt: datetimeSchema7.nullable()
+});
+var integrationJustEatDetailsSchema = integrationJustEatSchema.extend(
+  integrationDetailsFieldsSchema.shape
+);
+var integrationJustEatEditableFieldsSchema = integrationJustEatSchema.pick({
+  name: true,
+  provider: true,
+  syncType: true,
+  defaultLanguage: true,
+  restaurantId: true,
+  skipNegativePrices: true,
+  skipInvalidItem: true,
+  autoAcceptOrders: true,
+  importTaggedItems: true,
+  tagsForImport: true
+}).partial();
+var integrationsJustEatQuerySchema = z27.object({
+  "order[createdAt]": sortDirSchema7.optional(),
+  "order[updatedAt]": sortDirSchema7.optional(),
+  "order[latestMenuCheckAt]": sortDirSchema7.optional(),
+  "order[latestMenuSyncAt]": sortDirSchema7.optional(),
+  "order[latestOpeningTimesSyncAt]": sortDirSchema7.optional(),
+  "order[nextSyncMenuScheduledAt]": sortDirSchema7.optional(),
+  name: z27.string().optional(),
+  restaurantId: z27.string().optional(),
+  "restaurantId[]": z27.array(z27.string()).optional(),
+  status: integrationStatusSchema.optional(),
+  "status[]": z27.array(integrationStatusSchema).optional(),
+  syncType: integrationJustEatPathSchema.optional(),
+  "syncType[]": z27.array(integrationJustEatPathSchema).optional(),
+  connectionId: z27.string().optional(),
+  "connectionId[]": z27.array(z27.string()).optional(),
+  skipInvalidItem: z27.coerce.boolean().optional(),
+  isValidMenu: z27.coerce.boolean().optional(),
+  "latestMenuCheckAt[before]": z27.string().optional(),
+  "latestMenuCheckAt[strictly_before]": z27.string().optional(),
+  "latestMenuCheckAt[after]": z27.string().optional(),
+  "latestMenuCheckAt[strictly_after]": z27.string().optional(),
+  "latestMenuSyncAt[before]": z27.string().optional(),
+  "latestMenuSyncAt[strictly_before]": z27.string().optional(),
+  "latestMenuSyncAt[after]": z27.string().optional(),
+  "latestMenuSyncAt[strictly_after]": z27.string().optional(),
+  "latestOpeningTimesSyncAt[before]": z27.string().optional(),
+  "latestOpeningTimesSyncAt[strictly_before]": z27.string().optional(),
+  "latestOpeningTimesSyncAt[after]": z27.string().optional(),
+  "latestOpeningTimesSyncAt[strictly_after]": z27.string().optional(),
+  "nextSyncMenuScheduledAt[before]": z27.string().optional(),
+  "nextSyncMenuScheduledAt[strictly_before]": z27.string().optional(),
+  "nextSyncMenuScheduledAt[after]": z27.string().optional(),
+  "nextSyncMenuScheduledAt[strictly_after]": z27.string().optional(),
+  service: integrationServiceSchema.extract(["justeat"]).optional(),
+  page: z27.coerce.number().optional()
+}).merge(timestampsFilterSchema6);
+var integrationJustEatSyncMenuProcessSchema = z27.object({
+  id: z27.string(),
+  ingestionSucceeded: z27.boolean().nullable(),
+  error: z27.any().nullable(),
+  createdAt: datetimeSchema7
+});
+var integrationJustEatSyncMenuProcessDetailsSchema = integrationJustEatSyncMenuProcessSchema.extend({
+  integration: integrationJustEatPathSchema
+});
+var integrationJustEatSyncMenuProcessesQuerySchema = z27.object({
+  "order[createdAt]": sortDirSchema7.optional(),
+  page: z27.coerce.number().optional()
+});
+
+// src/integration-schemas.ts
+var integrationSchema = z28.discriminatedUnion("service", [
+  integrationJustEatSchema,
+  integrationDeliverooSchema,
+  integrationGlovoSchema,
+  integrationCassaInCloudSchema
+]);
+var integrationDetailsSchema = z28.discriminatedUnion("service", [
+  integrationJustEatDetailsSchema,
+  integrationDeliverooDetailsSchema,
+  integrationGlovoDetailsSchema,
+  integrationCassaInCloudDetailsSchema
+]);
+
+// src/requests/GetIntegrationDetails.ts
+var getIntegrationDetailsInputSchema = z29.undefined();
+var getIntegrationDetailsResponseSchema = integrationDetailsSchema;
+var GetIntegrationDetails = class extends AbstractApiRequest16 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDetailsInputSchema;
+  outputSchema = getIntegrationDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationId;
+  constructor(integrationId) {
+    super();
+    this.integrationId = integrationId;
+  }
+  getPath() {
+    return `/integrations/${this.integrationId}`;
+  }
+};
+
+// src/requests/GetIntegrations.ts
+import { AbstractApiRequest as AbstractApiRequest17 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema3,
+  responseToPagination as responseToPagination3,
+  sortDirSchema as sortDirSchema8,
+  timestampsFilterSchema as timestampsFilterSchema7
+} from "@deliverart/sdk-js-global-types";
+import { z as z30 } from "zod";
+var getIntegrationsQuerySchema = z30.object({
+  status: integrationStatusSchema.optional(),
+  "status[]": z30.array(integrationStatusSchema).optional(),
+  connectionId: z30.string().optional(),
+  "connectionId[]": z30.array(z30.string()).optional(),
+  service: integrationServiceSchema.optional(),
+  "order[createdAt]": sortDirSchema8.optional(),
+  "order[updatedAt]": sortDirSchema8.optional(),
+  page: z30.coerce.number().optional()
+}).merge(timestampsFilterSchema7);
+var getIntegrationsResponseSchema = createPaginatedSchema3(integrationSchema);
+var getIntegrationsInputSchema = z30.undefined();
+var GetIntegrations = class extends AbstractApiRequest17 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationsInputSchema;
+  outputSchema = getIntegrationsResponseSchema;
+  querySchema = getIntegrationsQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/integrations";
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z30.array(integrationSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination3(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/cassa_in_cloud/CreateIntegrationCassaInCloud.ts
+import { AbstractApiRequest as AbstractApiRequest18 } from "@deliverart/sdk-js-core";
+import { pointOfSalePathSchema as pointOfSalePathSchema4 } from "@deliverart/sdk-js-point-of-sale";
+var createIntegrationCassaInCloudInputSchema = integrationCassaInCloudEditableFieldsSchema.extend({
+  pointOfSale: pointOfSalePathSchema4
+});
+var createIntegrationCassaInCloudResponseSchema = integrationCassaInCloudDetailsSchema;
+var CreateIntegrationCassaInCloud = class extends AbstractApiRequest18 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createIntegrationCassaInCloudInputSchema;
+  outputSchema = createIntegrationCassaInCloudResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/integrations/cassa_in_cloud";
+  }
+};
+
+// src/requests/services/cassa_in_cloud/DeleteIntegrationCassaInCloud.ts
+import { AbstractApiRequest as AbstractApiRequest19 } from "@deliverart/sdk-js-core";
+import { z as z31 } from "zod";
+var deleteIntegrationCassaInCloudInputSchema = z31.undefined();
+var deleteIntegrationCassaInCloudResponseSchema = z31.undefined();
+var DeleteIntegrationCassaInCloud = class extends AbstractApiRequest19 {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteIntegrationCassaInCloudInputSchema;
+  outputSchema = deleteIntegrationCassaInCloudResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/GetIntegrationCassaInCloudClientLogRequestDetails.ts
+import { AbstractApiRequest as AbstractApiRequest20 } from "@deliverart/sdk-js-core";
+import { z as z32 } from "zod";
+var getIntegrationCassaInCloudClientLogRequestDetailsInputSchema = z32.undefined();
+var getIntegrationCassaInCloudClientLogRequestDetailsResponseSchema = integrationClientLogRequestDetailsSchema;
+var GetIntegrationCassaInCloudClientLogRequestDetails = class extends AbstractApiRequest20 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCassaInCloudClientLogRequestDetailsInputSchema;
+  outputSchema = getIntegrationCassaInCloudClientLogRequestDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  requestId;
+  constructor(integrationCassaInCloudId, requestId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+    this.requestId = requestId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/client_log_requests/${this.requestId}`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/GetIntegrationCassaInCloudClientLogRequests.ts
+import { AbstractApiRequest as AbstractApiRequest21 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema4,
+  responseToPagination as responseToPagination4
+} from "@deliverart/sdk-js-global-types";
+import { z as z33 } from "zod";
+var getIntegrationCassaInCloudClientLogRequestsQuerySchema = clientLogRequestQuerySchema;
+var getIntegrationCassaInCloudClientLogRequestsResponseSchema = createPaginatedSchema4(
+  integrationClientLogRequestSchema
+);
+var getIntegrationCassaInCloudClientLogRequestsInputSchema = z33.undefined();
+var GetIntegrationCassaInCloudClientLogRequests = class extends AbstractApiRequest21 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCassaInCloudClientLogRequestsInputSchema;
+  outputSchema = getIntegrationCassaInCloudClientLogRequestsResponseSchema;
+  querySchema = getIntegrationCassaInCloudClientLogRequestsQuerySchema;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId, options) {
+    super(void 0, options);
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/client_log_requests`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z33.array(integrationClientLogRequestSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination4(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/cassa_in_cloud/GetIntegrationCassaInCloudDetails.ts
+import { AbstractApiRequest as AbstractApiRequest22 } from "@deliverart/sdk-js-core";
+import { z as z34 } from "zod";
+var getIntegrationCassaInCloudDetailsInputSchema = z34.undefined();
+var getIntegrationCassaInCloudDetailsResponseSchema = integrationCassaInCloudDetailsSchema;
+var GetIntegrationCassaInCloudDetails = class extends AbstractApiRequest22 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCassaInCloudDetailsInputSchema;
+  outputSchema = getIntegrationCassaInCloudDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/GetIntegrationCassaInCloudList.ts
+import { AbstractApiRequest as AbstractApiRequest23 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema5,
+  responseToPagination as responseToPagination5
+} from "@deliverart/sdk-js-global-types";
+import { z as z35 } from "zod";
+var getIntegrationCassaInCloudListQuerySchema = integrationsCassaInCloudQuerySchema.omit({
+  service: true
+});
+var getIntegrationCassaInCloudListResponseSchema = createPaginatedSchema5(
+  integrationCassaInCloudSchema
+);
+var getIntegrationCassaInCloudListInputSchema = z35.undefined();
+var GetIntegrationCassaInCloudList = class extends AbstractApiRequest23 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCassaInCloudListInputSchema;
+  outputSchema = getIntegrationCassaInCloudListResponseSchema;
+  querySchema = getIntegrationCassaInCloudListQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/integrations/cassa_in_cloud";
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z35.array(integrationCassaInCloudSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination5(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/cassa_in_cloud/GetIntegrationCassaInCloudSyncMenuProcessDetails.ts
+import { AbstractApiRequest as AbstractApiRequest24 } from "@deliverart/sdk-js-core";
+import { z as z36 } from "zod";
+var getIntegrationCassaInCloudSyncMenuProcessDetailsInputSchema = z36.undefined();
+var getIntegrationCassaInCloudSyncMenuProcessDetailsResponseSchema = integrationCassaInCloudSyncMenuProcessDetailsSchema;
+var GetIntegrationCassaInCloudSyncMenuProcessDetails = class extends AbstractApiRequest24 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCassaInCloudSyncMenuProcessDetailsInputSchema;
+  outputSchema = getIntegrationCassaInCloudSyncMenuProcessDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  processId;
+  constructor(integrationCassaInCloudId, processId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+    this.processId = processId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/sync_menu_processes/${this.processId}`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/GetIntegrationCassaInCloudSyncMenuProcesses.ts
+import { AbstractApiRequest as AbstractApiRequest25 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema6,
+  responseToPagination as responseToPagination6
+} from "@deliverart/sdk-js-global-types";
+import { z as z37 } from "zod";
+var getIntegrationCassaInCloudSyncMenuProcessesQuerySchema = z37.object({
+  page: z37.number().optional()
+});
+var getIntegrationCassaInCloudSyncMenuProcessesResponseSchema = createPaginatedSchema6(
+  integrationCassaInCloudSyncMenuProcessSchema
+);
+var getIntegrationCassaInCloudSyncMenuProcessesInputSchema = z37.undefined();
+var GetIntegrationCassaInCloudSyncMenuProcesses = class extends AbstractApiRequest25 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCassaInCloudSyncMenuProcessesInputSchema;
+  outputSchema = getIntegrationCassaInCloudSyncMenuProcessesResponseSchema;
+  querySchema = getIntegrationCassaInCloudSyncMenuProcessesQuerySchema;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId, options) {
+    super(void 0, options);
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/sync_menu_processes`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z37.array(integrationCassaInCloudSyncMenuProcessSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination6(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/cassa_in_cloud/GetIntegrationCassaInCloudWebHookEventDetails.ts
+import { AbstractApiRequest as AbstractApiRequest26 } from "@deliverart/sdk-js-core";
+import { z as z38 } from "zod";
+var getIntegrationCassaInCloudWebHookEventDetailsInputSchema = z38.undefined();
+var getIntegrationCassaInCloudWebHookEventDetailsResponseSchema = integrationCassaInCloudWebHookEventDetailsSchema;
+var GetIntegrationCassaInCloudWebHookEventDetails = class extends AbstractApiRequest26 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCassaInCloudWebHookEventDetailsInputSchema;
+  outputSchema = getIntegrationCassaInCloudWebHookEventDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  eventId;
+  constructor(integrationCassaInCloudId, eventId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+    this.eventId = eventId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/webhook_events/${this.eventId}`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/GetIntegrationCassaInCloudWebHookEvents.ts
+import { AbstractApiRequest as AbstractApiRequest27 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema7,
+  responseToPagination as responseToPagination7
+} from "@deliverart/sdk-js-global-types";
+import { z as z39 } from "zod";
+var getIntegrationCassaInCloudWebHookEventsQuerySchema = integrationCassaInCloudWebHookEventsQuerySchema;
+var getIntegrationCassaInCloudWebHookEventsResponseSchema = createPaginatedSchema7(
+  integrationCassaInCloudWebHookEventSchema
+);
+var getIntegrationCassaInCloudWebHookEventsInputSchema = z39.undefined();
+var GetIntegrationCassaInCloudWebHookEvents = class extends AbstractApiRequest27 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationCassaInCloudWebHookEventsInputSchema;
+  outputSchema = getIntegrationCassaInCloudWebHookEventsResponseSchema;
+  querySchema = getIntegrationCassaInCloudWebHookEventsQuerySchema;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId, options) {
+    super(void 0, options);
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/webhook_events`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z39.array(integrationCassaInCloudWebHookEventSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination7(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/cassa_in_cloud/IntegrationCassaInCloudSyncCustomers.ts
+import { AbstractApiRequest as AbstractApiRequest28 } from "@deliverart/sdk-js-core";
+import { z as z40 } from "zod";
+var integrationCassaInCloudSyncCustomersInputSchema = z40.undefined();
+var integrationCassaInCloudSyncCustomersResponseSchema = z40.undefined();
+var IntegrationCassaInCloudSyncCustomers = class extends AbstractApiRequest28 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationCassaInCloudSyncCustomersInputSchema;
+  outputSchema = integrationCassaInCloudSyncCustomersResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/sync/customers`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/IntegrationCassaInCloudSyncOrganizations.ts
+import { AbstractApiRequest as AbstractApiRequest29 } from "@deliverart/sdk-js-core";
+import { z as z41 } from "zod";
+var integrationCassaInCloudSyncOrganizationsInputSchema = z41.undefined();
+var integrationCassaInCloudSyncOrganizationsResponseSchema = z41.undefined();
+var IntegrationCassaInCloudSyncOrganizations = class extends AbstractApiRequest29 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationCassaInCloudSyncOrganizationsInputSchema;
+  outputSchema = integrationCassaInCloudSyncOrganizationsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/sync/organizations`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/IntegrationCassaInCloudSyncProducts.ts
+import { AbstractApiRequest as AbstractApiRequest30 } from "@deliverart/sdk-js-core";
+import { z as z42 } from "zod";
+var integrationCassaInCloudSyncProductsInputSchema = z42.undefined();
+var integrationCassaInCloudSyncProductsResponseSchema = z42.undefined();
+var IntegrationCassaInCloudSyncProducts = class extends AbstractApiRequest30 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationCassaInCloudSyncProductsInputSchema;
+  outputSchema = integrationCassaInCloudSyncProductsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/sync/products`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/IntegrationCassaInCloudSyncSalesModes.ts
+import { AbstractApiRequest as AbstractApiRequest31 } from "@deliverart/sdk-js-core";
+import { z as z43 } from "zod";
+var integrationCassaInCloudSyncSalesModesInputSchema = z43.undefined();
+var integrationCassaInCloudSyncSalesModesResponseSchema = z43.undefined();
+var IntegrationCassaInCloudSyncSalesModes = class extends AbstractApiRequest31 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationCassaInCloudSyncSalesModesInputSchema;
+  outputSchema = integrationCassaInCloudSyncSalesModesResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/sync/sales_modes`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/IntegrationCassaInCloudSyncStock.ts
+import { AbstractApiRequest as AbstractApiRequest32 } from "@deliverart/sdk-js-core";
+import { z as z44 } from "zod";
+var integrationCassaInCloudSyncStockInputSchema = z44.undefined();
+var integrationCassaInCloudSyncStockResponseSchema = z44.undefined();
+var IntegrationCassaInCloudSyncStock = class extends AbstractApiRequest32 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationCassaInCloudSyncStockInputSchema;
+  outputSchema = integrationCassaInCloudSyncStockResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/sync/stock`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/IntegrationCassaInCloudSyncTimetables.ts
+import { AbstractApiRequest as AbstractApiRequest33 } from "@deliverart/sdk-js-core";
+import { z as z45 } from "zod";
+var integrationCassaInCloudSyncTimetablesInputSchema = z45.undefined();
+var integrationCassaInCloudSyncTimetablesResponseSchema = z45.undefined();
+var IntegrationCassaInCloudSyncTimetables = class extends AbstractApiRequest33 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationCassaInCloudSyncTimetablesInputSchema;
+  outputSchema = integrationCassaInCloudSyncTimetablesResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId) {
+    super();
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}/sync/timetables`;
+  }
+};
+
+// src/requests/services/cassa_in_cloud/UpdateIntegrationCassaInCloud.ts
+import { AbstractApiRequest as AbstractApiRequest34 } from "@deliverart/sdk-js-core";
+var updateIntegrationCassaInCloudInputSchema = integrationCassaInCloudEditableFieldsSchema;
+var updateIntegrationCassaInCloudResponseSchema = integrationCassaInCloudDetailsSchema;
+var UpdateIntegrationCassaInCloud = class extends AbstractApiRequest34 {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateIntegrationCassaInCloudInputSchema;
+  outputSchema = updateIntegrationCassaInCloudResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationCassaInCloudId;
+  constructor(integrationCassaInCloudId, input) {
+    super(input);
+    this.integrationCassaInCloudId = integrationCassaInCloudId;
+  }
+  getPath() {
+    return `/integrations/cassa_in_cloud/${this.integrationCassaInCloudId}`;
+  }
+};
+
+// src/requests/services/deliveroo/CreateIntegrationDeliveroo.ts
+import { AbstractApiRequest as AbstractApiRequest35 } from "@deliverart/sdk-js-core";
+import { pointOfSalePathSchema as pointOfSalePathSchema5 } from "@deliverart/sdk-js-point-of-sale";
+var createIntegrationDeliverooInputSchema = integrationDeliverooEditableFieldsSchema.extend({
+  pointOfSale: pointOfSalePathSchema5
+});
+var createIntegrationDeliverooResponseSchema = integrationDeliverooDetailsSchema;
+var CreateIntegrationDeliveroo = class extends AbstractApiRequest35 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createIntegrationDeliverooInputSchema;
+  outputSchema = createIntegrationDeliverooResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/integrations/deliveroo";
+  }
+};
+
+// src/requests/services/deliveroo/DeleteIntegrationDeliveroo.ts
+import { AbstractApiRequest as AbstractApiRequest36 } from "@deliverart/sdk-js-core";
+import { z as z46 } from "zod";
+var deleteIntegrationDeliverooInputSchema = z46.undefined();
+var deleteIntegrationDeliverooResponseSchema = z46.undefined();
+var DeleteIntegrationDeliveroo = class extends AbstractApiRequest36 {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteIntegrationDeliverooInputSchema;
+  outputSchema = deleteIntegrationDeliverooResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId) {
+    super();
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}`;
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooClientLogRequestDetails.ts
+import { AbstractApiRequest as AbstractApiRequest37 } from "@deliverart/sdk-js-core";
+import { z as z47 } from "zod";
+var getIntegrationDeliverooClientLogRequestDetailsInputSchema = z47.undefined();
+var getIntegrationDeliverooClientLogRequestDetailsResponseSchema = integrationClientLogRequestDetailsSchema;
+var GetIntegrationDeliverooClientLogRequestDetails = class extends AbstractApiRequest37 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooClientLogRequestDetailsInputSchema;
+  outputSchema = getIntegrationDeliverooClientLogRequestDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  requestId;
+  constructor(integrationDeliverooId, requestId) {
+    super();
+    this.integrationDeliverooId = integrationDeliverooId;
+    this.requestId = requestId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/client_log_requests/${this.requestId}`;
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooClientLogRequests.ts
+import { AbstractApiRequest as AbstractApiRequest38 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema8,
+  responseToPagination as responseToPagination8
+} from "@deliverart/sdk-js-global-types";
+import { z as z48 } from "zod";
+var getIntegrationDeliverooClientLogRequestsQuerySchema = clientLogRequestQuerySchema;
+var getIntegrationDeliverooClientLogRequestsResponseSchema = createPaginatedSchema8(
+  integrationClientLogRequestSchema
+);
+var getIntegrationDeliverooClientLogRequestsInputSchema = z48.undefined();
+var GetIntegrationDeliverooClientLogRequests = class extends AbstractApiRequest38 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooClientLogRequestsInputSchema;
+  outputSchema = getIntegrationDeliverooClientLogRequestsResponseSchema;
+  querySchema = getIntegrationDeliverooClientLogRequestsQuerySchema;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId, options) {
+    super(void 0, options);
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/client_log_requests`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z48.array(integrationClientLogRequestSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination8(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooDetails.ts
+import { AbstractApiRequest as AbstractApiRequest39 } from "@deliverart/sdk-js-core";
+import { z as z49 } from "zod";
+var getIntegrationDeliverooDetailsInputSchema = z49.undefined();
+var getIntegrationDeliverooDetailsResponseSchema = integrationDeliverooDetailsSchema;
+var GetIntegrationDeliverooDetails = class extends AbstractApiRequest39 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooDetailsInputSchema;
+  outputSchema = getIntegrationDeliverooDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId) {
+    super();
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}`;
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooList.ts
+import { AbstractApiRequest as AbstractApiRequest40 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema9,
+  responseToPagination as responseToPagination9
+} from "@deliverart/sdk-js-global-types";
+import { z as z50 } from "zod";
+var getIntegrationDeliverooListQuerySchema = integrationsDeliverooQuerySchema.omit({
+  service: true
+});
+var getIntegrationDeliverooListResponseSchema = createPaginatedSchema9(
+  integrationDeliverooSchema
+);
+var getIntegrationDeliverooListInputSchema = z50.undefined();
+var GetIntegrationDeliverooList = class extends AbstractApiRequest40 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooListInputSchema;
+  outputSchema = getIntegrationDeliverooListResponseSchema;
+  querySchema = getIntegrationDeliverooListQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/integrations/deliveroo";
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z50.array(integrationDeliverooSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination9(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooMenuVersionDetails.ts
+import { AbstractApiRequest as AbstractApiRequest41 } from "@deliverart/sdk-js-core";
+import { z as z51 } from "zod";
+var getIntegrationDeliverooMenuVersionDetailsInputSchema = z51.undefined();
+var getIntegrationDeliverooMenuVersionDetailsResponseSchema = menuVersionDetailsSchema;
+var GetIntegrationDeliverooMenuVersionDetails = class extends AbstractApiRequest41 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooMenuVersionDetailsInputSchema;
+  outputSchema = getIntegrationDeliverooMenuVersionDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  versionId;
+  constructor(integrationDeliverooId, versionId) {
+    super();
+    this.integrationDeliverooId = integrationDeliverooId;
+    this.versionId = versionId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/menu_versions/${this.versionId}`;
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooMenuVersions.ts
+import { AbstractApiRequest as AbstractApiRequest42 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema10,
+  responseToPagination as responseToPagination10
+} from "@deliverart/sdk-js-global-types";
+import { z as z52 } from "zod";
+var getIntegrationDeliverooMenuVersionsQuerySchema = z52.object({
+  page: z52.number().optional()
+});
+var getIntegrationDeliverooMenuVersionsResponseSchema = createPaginatedSchema10(menuVersionSchema);
+var getIntegrationDeliverooMenuVersionsInputSchema = z52.undefined();
+var GetIntegrationDeliverooMenuVersions = class extends AbstractApiRequest42 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooMenuVersionsInputSchema;
+  outputSchema = getIntegrationDeliverooMenuVersionsResponseSchema;
+  querySchema = getIntegrationDeliverooMenuVersionsQuerySchema;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId, options) {
+    super(void 0, options);
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/menu_versions`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z52.array(menuVersionSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination10(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooSyncMenuProcessDetails.ts
+import { AbstractApiRequest as AbstractApiRequest43 } from "@deliverart/sdk-js-core";
+import { z as z53 } from "zod";
+var getIntegrationDeliverooSyncMenuProcessDetailsInputSchema = z53.undefined();
+var getIntegrationDeliverooSyncMenuProcessDetailsResponseSchema = integrationDeliverooSyncMenuProcessDetailsSchema;
+var GetIntegrationDeliverooSyncMenuProcessDetails = class extends AbstractApiRequest43 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooSyncMenuProcessDetailsInputSchema;
+  outputSchema = getIntegrationDeliverooSyncMenuProcessDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  processId;
+  constructor(integrationDeliverooId, processId) {
+    super();
+    this.integrationDeliverooId = integrationDeliverooId;
+    this.processId = processId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/sync_menu_processes/${this.processId}`;
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooSyncMenuProcesses.ts
+import { AbstractApiRequest as AbstractApiRequest44 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema11,
+  responseToPagination as responseToPagination11
+} from "@deliverart/sdk-js-global-types";
+import { z as z54 } from "zod";
+var getIntegrationDeliverooSyncMenuProcessesQuerySchema = z54.object({
+  page: z54.number().optional()
+});
+var getIntegrationDeliverooSyncMenuProcessesResponseSchema = createPaginatedSchema11(
+  integrationDeliverooSyncMenuProcessSchema
+);
+var getIntegrationDeliverooSyncMenuProcessesInputSchema = z54.undefined();
+var GetIntegrationDeliverooSyncMenuProcesses = class extends AbstractApiRequest44 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooSyncMenuProcessesInputSchema;
+  outputSchema = getIntegrationDeliverooSyncMenuProcessesResponseSchema;
+  querySchema = getIntegrationDeliverooSyncMenuProcessesQuerySchema;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId, options) {
+    super(void 0, options);
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/sync_menu_processes`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z54.array(integrationDeliverooSyncMenuProcessSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination11(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooWebhookEventDetails.ts
+import { AbstractApiRequest as AbstractApiRequest45 } from "@deliverart/sdk-js-core";
+import { z as z55 } from "zod";
+var getIntegrationDeliverooWebhookEventDetailsInputSchema = z55.undefined();
+var getIntegrationDeliverooWebhookEventDetailsResponseSchema = integrationDeliverooWebhookEventDetailsSchema;
+var GetIntegrationDeliverooWebhookEventDetails = class extends AbstractApiRequest45 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooWebhookEventDetailsInputSchema;
+  outputSchema = getIntegrationDeliverooWebhookEventDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  eventId;
+  constructor(integrationDeliverooId, eventId) {
+    super();
+    this.integrationDeliverooId = integrationDeliverooId;
+    this.eventId = eventId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/webhook_events/${this.eventId}`;
+  }
+};
+
+// src/requests/services/deliveroo/GetIntegrationDeliverooWebhookEvents.ts
+import { AbstractApiRequest as AbstractApiRequest46 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema12,
+  responseToPagination as responseToPagination12
+} from "@deliverart/sdk-js-global-types";
+import { z as z56 } from "zod";
+var getIntegrationDeliverooWebhookEventsQuerySchema = integrationDeliverooWebhookEventsQueryParamsSchema;
+var getIntegrationDeliverooWebhookEventsResponseSchema = createPaginatedSchema12(
+  integrationDeliverooWebhookEventSchema
+);
+var getIntegrationDeliverooWebhookEventsInputSchema = z56.undefined();
+var GetIntegrationDeliverooWebhookEvents = class extends AbstractApiRequest46 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationDeliverooWebhookEventsInputSchema;
+  outputSchema = getIntegrationDeliverooWebhookEventsResponseSchema;
+  querySchema = getIntegrationDeliverooWebhookEventsQuerySchema;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId, options) {
+    super(void 0, options);
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/webhook_events`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z56.array(integrationDeliverooWebhookEventSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination12(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/deliveroo/IntegrationDeliverooSyncMenu.ts
+import { AbstractApiRequest as AbstractApiRequest47 } from "@deliverart/sdk-js-core";
+import { z as z57 } from "zod";
+var integrationDeliverooSyncMenuInputSchema = z57.undefined();
+var integrationDeliverooSyncMenuResponseSchema = z57.undefined();
+var IntegrationDeliverooSyncMenu = class extends AbstractApiRequest47 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationDeliverooSyncMenuInputSchema;
+  outputSchema = integrationDeliverooSyncMenuResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId) {
+    super();
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/sync/menu`;
+  }
+};
+
+// src/requests/services/deliveroo/IntegrationDeliverooSyncOpeningHours.ts
+import { AbstractApiRequest as AbstractApiRequest48 } from "@deliverart/sdk-js-core";
+import { z as z58 } from "zod";
+var integrationDeliverooSyncOpeningHoursInputSchema = z58.undefined();
+var integrationDeliverooSyncOpeningHoursResponseSchema = z58.undefined();
+var IntegrationDeliverooSyncOpeningHours = class extends AbstractApiRequest48 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationDeliverooSyncOpeningHoursInputSchema;
+  outputSchema = integrationDeliverooSyncOpeningHoursResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId) {
+    super();
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/sync/opening_hours`;
+  }
+};
+
+// src/requests/services/deliveroo/UpdateIntegrationDeliveroo.ts
+import { AbstractApiRequest as AbstractApiRequest49 } from "@deliverart/sdk-js-core";
+var updateIntegrationDeliverooInputSchema = integrationDeliverooEditableFieldsSchema;
+var updateIntegrationDeliverooResponseSchema = integrationDeliverooDetailsSchema;
+var UpdateIntegrationDeliveroo = class extends AbstractApiRequest49 {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateIntegrationDeliverooInputSchema;
+  outputSchema = updateIntegrationDeliverooResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId, input) {
+    super(input);
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}`;
+  }
+};
+
+// src/requests/services/deliveroo/UpdateIntegrationDeliverooSiteStatus.ts
+import { AbstractApiRequest as AbstractApiRequest50 } from "@deliverart/sdk-js-core";
+import { z as z59 } from "zod";
+var updateIntegrationDeliverooSiteStatusInputSchema = z59.object({
+  status: integrationDeliverooSiteStatusSchema
+});
+var updateIntegrationDeliverooSiteStatusResponseSchema = integrationDeliverooDetailsSchema;
+var UpdateIntegrationDeliverooSiteStatus = class extends AbstractApiRequest50 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = updateIntegrationDeliverooSiteStatusInputSchema;
+  outputSchema = updateIntegrationDeliverooSiteStatusResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationDeliverooId;
+  constructor(integrationDeliverooId, input) {
+    super(input);
+    this.integrationDeliverooId = integrationDeliverooId;
+  }
+  getPath() {
+    return `/integrations/deliveroo/${this.integrationDeliverooId}/site/status`;
+  }
+};
+
+// src/requests/services/glovo/CreateIntegrationGlovo.ts
+import { AbstractApiRequest as AbstractApiRequest51 } from "@deliverart/sdk-js-core";
+import { pointOfSalePathSchema as pointOfSalePathSchema6 } from "@deliverart/sdk-js-point-of-sale";
+var createIntegrationGlovoInputSchema = integrationGlovoEditableFieldsSchema.extend({
+  pointOfSale: pointOfSalePathSchema6
+});
+var createIntegrationGlovoResponseSchema = integrationGlovoDetailsSchema;
+var CreateIntegrationGlovo = class extends AbstractApiRequest51 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createIntegrationGlovoInputSchema;
+  outputSchema = createIntegrationGlovoResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/integrations/glovo";
+  }
+};
+
+// src/requests/services/glovo/DeleteIntegrationGlovo.ts
+import { AbstractApiRequest as AbstractApiRequest52 } from "@deliverart/sdk-js-core";
+import { z as z60 } from "zod";
+var deleteIntegrationGlovoInputSchema = z60.undefined();
+var deleteIntegrationGlovoResponseSchema = z60.undefined();
+var DeleteIntegrationGlovo = class extends AbstractApiRequest52 {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteIntegrationGlovoInputSchema;
+  outputSchema = deleteIntegrationGlovoResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  constructor(integrationGlovoId) {
+    super();
+    this.integrationGlovoId = integrationGlovoId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}`;
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoClientLogRequestDetails.ts
+import { AbstractApiRequest as AbstractApiRequest53 } from "@deliverart/sdk-js-core";
+import { z as z61 } from "zod";
+var getIntegrationGlovoClientLogRequestDetailsInputSchema = z61.undefined();
+var getIntegrationGlovoClientLogRequestDetailsResponseSchema = integrationClientLogRequestDetailsSchema;
+var GetIntegrationGlovoClientLogRequestDetails = class extends AbstractApiRequest53 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoClientLogRequestDetailsInputSchema;
+  outputSchema = getIntegrationGlovoClientLogRequestDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  requestId;
+  constructor(integrationGlovoId, requestId) {
+    super();
+    this.integrationGlovoId = integrationGlovoId;
+    this.requestId = requestId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/client_log_requests/${this.requestId}`;
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoClientLogRequests.ts
+import { AbstractApiRequest as AbstractApiRequest54 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema13,
+  responseToPagination as responseToPagination13
+} from "@deliverart/sdk-js-global-types";
+import { z as z62 } from "zod";
+var getIntegrationGlovoClientLogRequestsQuerySchema = clientLogRequestQuerySchema;
+var getIntegrationGlovoClientLogRequestsResponseSchema = createPaginatedSchema13(
+  integrationClientLogRequestSchema
+);
+var getIntegrationGlovoClientLogRequestsInputSchema = z62.undefined();
+var GetIntegrationGlovoClientLogRequests = class extends AbstractApiRequest54 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoClientLogRequestsInputSchema;
+  outputSchema = getIntegrationGlovoClientLogRequestsResponseSchema;
+  querySchema = getIntegrationGlovoClientLogRequestsQuerySchema;
+  headersSchema = void 0;
+  integrationGlovoId;
+  constructor(integrationGlovoId, options) {
+    super(void 0, options);
+    this.integrationGlovoId = integrationGlovoId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/client_log_requests`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z62.array(integrationClientLogRequestSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination13(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoDetails.ts
+import { AbstractApiRequest as AbstractApiRequest55 } from "@deliverart/sdk-js-core";
+import { z as z63 } from "zod";
+var getIntegrationGlovoDetailsInputSchema = z63.undefined();
+var getIntegrationGlovoDetailsResponseSchema = integrationGlovoDetailsSchema;
+var GetIntegrationGlovoDetails = class extends AbstractApiRequest55 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoDetailsInputSchema;
+  outputSchema = getIntegrationGlovoDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  constructor(integrationGlovoId) {
+    super();
+    this.integrationGlovoId = integrationGlovoId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}`;
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoList.ts
+import { AbstractApiRequest as AbstractApiRequest56 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema14,
+  responseToPagination as responseToPagination14
+} from "@deliverart/sdk-js-global-types";
+import { z as z64 } from "zod";
+var getIntegrationGlovoListQuerySchema = integrationsGlovoQuerySchema.omit({
+  service: true
+});
+var getIntegrationGlovoListResponseSchema = createPaginatedSchema14(integrationGlovoSchema);
+var getIntegrationGlovoListInputSchema = z64.undefined();
+var GetIntegrationGlovoList = class extends AbstractApiRequest56 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoListInputSchema;
+  outputSchema = getIntegrationGlovoListResponseSchema;
+  querySchema = getIntegrationGlovoListQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/integrations/glovo";
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z64.array(integrationGlovoSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination14(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoMenuUpdateDetails.ts
+import { AbstractApiRequest as AbstractApiRequest57 } from "@deliverart/sdk-js-core";
+import { z as z65 } from "zod";
+var getIntegrationGlovoMenuUpdateDetailsInputSchema = z65.undefined();
+var getIntegrationGlovoMenuUpdateDetailsResponseSchema = integrationGlovoMenuUpdateDetailsSchema;
+var GetIntegrationGlovoMenuUpdateDetails = class extends AbstractApiRequest57 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoMenuUpdateDetailsInputSchema;
+  outputSchema = getIntegrationGlovoMenuUpdateDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  processId;
+  constructor(integrationGlovoId, processId) {
+    super();
+    this.integrationGlovoId = integrationGlovoId;
+    this.processId = processId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/menu_updates/${this.processId}`;
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoMenuUpdates.ts
+import { AbstractApiRequest as AbstractApiRequest58 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema15,
+  responseToPagination as responseToPagination15
+} from "@deliverart/sdk-js-global-types";
+import { z as z66 } from "zod";
+var getIntegrationGlovoMenuUpdatesQuerySchema = z66.object({
+  page: z66.number().optional()
+});
+var getIntegrationGlovoMenuUpdatesResponseSchema = createPaginatedSchema15(
+  integrationGlovoMenuUpdateSchema
+);
+var getIntegrationGlovoMenuUpdatesInputSchema = z66.undefined();
+var GetIntegrationGlovoMenuUpdates = class extends AbstractApiRequest58 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoMenuUpdatesInputSchema;
+  outputSchema = getIntegrationGlovoMenuUpdatesResponseSchema;
+  querySchema = getIntegrationGlovoMenuUpdatesQuerySchema;
+  headersSchema = void 0;
+  integrationId;
+  constructor(integrationId, options) {
+    super(void 0, options);
+    this.integrationId = integrationId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationId}/menu_updates`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z66.array(integrationGlovoMenuUpdateSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination15(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoMenuVersionDetails.ts
+import { AbstractApiRequest as AbstractApiRequest59 } from "@deliverart/sdk-js-core";
+import { z as z67 } from "zod";
+var getIntegrationGlovoMenuVersionDetailsInputSchema = z67.undefined();
+var getIntegrationGlovoMenuVersionDetailsResponseSchema = menuVersionDetailsSchema;
+var GetIntegrationGlovoMenuVersionDetails = class extends AbstractApiRequest59 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoMenuVersionDetailsInputSchema;
+  outputSchema = getIntegrationGlovoMenuVersionDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  versionId;
+  constructor(integrationGlovoId, versionId) {
+    super();
+    this.integrationGlovoId = integrationGlovoId;
+    this.versionId = versionId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/menu_versions/${this.versionId}`;
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoMenuVersions.ts
+import { AbstractApiRequest as AbstractApiRequest60 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema16,
+  responseToPagination as responseToPagination16
+} from "@deliverart/sdk-js-global-types";
+import { z as z68 } from "zod";
+var getIntegrationGlovoMenuVersionsQuerySchema = z68.object({
+  page: z68.number().optional()
+});
+var getIntegrationGlovoMenuVersionsResponseSchema = createPaginatedSchema16(menuVersionSchema);
+var getIntegrationGlovoMenuVersionsInputSchema = z68.undefined();
+var GetIntegrationGlovoMenuVersions = class extends AbstractApiRequest60 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoMenuVersionsInputSchema;
+  outputSchema = getIntegrationGlovoMenuVersionsResponseSchema;
+  querySchema = getIntegrationGlovoMenuVersionsQuerySchema;
+  headersSchema = void 0;
+  integrationGlovoId;
+  constructor(integrationGlovoId, options) {
+    super(void 0, options);
+    this.integrationGlovoId = integrationGlovoId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/menu_versions`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z68.array(menuVersionSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination16(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoWebhookEventDetails.ts
+import { AbstractApiRequest as AbstractApiRequest61 } from "@deliverart/sdk-js-core";
+import { z as z69 } from "zod";
+var getIntegrationGlovoWebhookEventDetailsInputSchema = z69.undefined();
+var getIntegrationGlovoWebhookEventDetailsResponseSchema = integrationGlovoWebhookEventDetailsSchema;
+var GetIntegrationGlovoWebhookEventDetails = class extends AbstractApiRequest61 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoWebhookEventDetailsInputSchema;
+  outputSchema = getIntegrationGlovoWebhookEventDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  eventId;
+  constructor(integrationGlovoId, eventId) {
+    super();
+    this.integrationGlovoId = integrationGlovoId;
+    this.eventId = eventId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/webhook_events/${this.eventId}`;
+  }
+};
+
+// src/requests/services/glovo/GetIntegrationGlovoWebhookEvents.ts
+import { AbstractApiRequest as AbstractApiRequest62 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema17,
+  responseToPagination as responseToPagination17
+} from "@deliverart/sdk-js-global-types";
+import { z as z70 } from "zod";
+var getIntegrationGlovoWebhookEventsQuerySchema = integrationGlovoWebhookEventsQueryParamsSchema;
+var getIntegrationGlovoWebhookEventsResponseSchema = createPaginatedSchema17(
+  integrationGlovoWebhookEventSchema
+);
+var getIntegrationGlovoWebhookEventsInputSchema = z70.undefined();
+var GetIntegrationGlovoWebhookEvents = class extends AbstractApiRequest62 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationGlovoWebhookEventsInputSchema;
+  outputSchema = getIntegrationGlovoWebhookEventsResponseSchema;
+  querySchema = getIntegrationGlovoWebhookEventsQuerySchema;
+  headersSchema = void 0;
+  integrationGlovoId;
+  constructor(integrationGlovoId, options) {
+    super(void 0, options);
+    this.integrationGlovoId = integrationGlovoId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/webhook_events`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z70.array(integrationGlovoWebhookEventSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination17(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/glovo/IntegrationGlovoSyncMenu.ts
+import { AbstractApiRequest as AbstractApiRequest63 } from "@deliverart/sdk-js-core";
+import { z as z71 } from "zod";
+var integrationGlovoSyncMenuInputSchema = z71.undefined();
+var integrationGlovoSyncMenuResponseSchema = z71.undefined();
+var IntegrationGlovoSyncMenu = class extends AbstractApiRequest63 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationGlovoSyncMenuInputSchema;
+  outputSchema = integrationGlovoSyncMenuResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  constructor(integrationGlovoId) {
+    super();
+    this.integrationGlovoId = integrationGlovoId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/sync/menu`;
+  }
+};
+
+// src/requests/services/glovo/UpdateIntegrationGlovo.ts
+import { AbstractApiRequest as AbstractApiRequest64 } from "@deliverart/sdk-js-core";
+var updateIntegrationGlovoInputSchema = integrationGlovoEditableFieldsSchema;
+var updateIntegrationGlovoResponseSchema = integrationGlovoDetailsSchema;
+var UpdateIntegrationGlovo = class extends AbstractApiRequest64 {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateIntegrationGlovoInputSchema;
+  outputSchema = updateIntegrationGlovoResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  constructor(integrationGlovoId, input) {
+    super(input);
+    this.integrationGlovoId = integrationGlovoId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}`;
+  }
+};
+
+// src/requests/services/glovo/UpdateIntegrationGlovoStoreStatus.ts
+import { AbstractApiRequest as AbstractApiRequest65 } from "@deliverart/sdk-js-core";
+import { z as z72 } from "zod";
+var updateIntegrationGlovoStoreStatusInputSchema = z72.object({
+  status: integrationGlovoStoreStatusSchema
+});
+var updateIntegrationGlovoStoreStatusResponseSchema = integrationGlovoDetailsSchema;
+var UpdateIntegrationGlovoStoreStatus = class extends AbstractApiRequest65 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = updateIntegrationGlovoStoreStatusInputSchema;
+  outputSchema = updateIntegrationGlovoStoreStatusResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationGlovoId;
+  constructor(integrationGlovoId, input) {
+    super(input);
+    this.integrationGlovoId = integrationGlovoId;
+  }
+  getPath() {
+    return `/integrations/glovo/${this.integrationGlovoId}/store/status`;
+  }
+};
+
+// src/requests/services/justeat/CreateIntegrationJustEat.ts
+import { AbstractApiRequest as AbstractApiRequest66 } from "@deliverart/sdk-js-core";
+import { pointOfSalePathSchema as pointOfSalePathSchema7 } from "@deliverart/sdk-js-point-of-sale";
+var createIntegrationJustEatInputSchema = integrationJustEatEditableFieldsSchema.extend({
+  pointOfSale: pointOfSalePathSchema7
+});
+var createIntegrationJustEatResponseSchema = integrationJustEatDetailsSchema;
+var CreateIntegrationJustEat = class extends AbstractApiRequest66 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createIntegrationJustEatInputSchema;
+  outputSchema = createIntegrationJustEatResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/integrations/justeat";
+  }
+};
+
+// src/requests/services/justeat/DeleteIntegrationJustEat.ts
+import { AbstractApiRequest as AbstractApiRequest67 } from "@deliverart/sdk-js-core";
+import { z as z73 } from "zod";
+var deleteIntegrationJustEatInputSchema = z73.undefined();
+var deleteIntegrationJustEatResponseSchema = z73.undefined();
+var DeleteIntegrationJustEat = class extends AbstractApiRequest67 {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deleteIntegrationJustEatInputSchema;
+  outputSchema = deleteIntegrationJustEatResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId) {
+    super();
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}`;
+  }
+};
+
+// src/requests/services/justeat/GetIntegrationJustEatClientLogRequestDetails.ts
+import { AbstractApiRequest as AbstractApiRequest68 } from "@deliverart/sdk-js-core";
+import { z as z74 } from "zod";
+var getIntegrationJustEatClientLogRequestDetailsInputSchema = z74.undefined();
+var getIntegrationJustEatClientLogRequestDetailsResponseSchema = integrationClientLogRequestDetailsSchema;
+var GetIntegrationJustEatClientLogRequestDetails = class extends AbstractApiRequest68 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationJustEatClientLogRequestDetailsInputSchema;
+  outputSchema = getIntegrationJustEatClientLogRequestDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  requestId;
+  constructor(integrationJustEatId, requestId) {
+    super();
+    this.integrationJustEatId = integrationJustEatId;
+    this.requestId = requestId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/client_log_requests/${this.requestId}`;
+  }
+};
+
+// src/requests/services/justeat/GetIntegrationJustEatClientLogRequests.ts
+import { AbstractApiRequest as AbstractApiRequest69 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema18,
+  responseToPagination as responseToPagination18
+} from "@deliverart/sdk-js-global-types";
+import { z as z75 } from "zod";
+var getIntegrationJustEatClientLogRequestsQuerySchema = clientLogRequestQuerySchema;
+var getIntegrationJustEatClientLogRequestsResponseSchema = createPaginatedSchema18(
+  integrationClientLogRequestSchema
+);
+var getIntegrationJustEatClientLogRequestsInputSchema = z75.undefined();
+var GetIntegrationJustEatClientLogRequests = class extends AbstractApiRequest69 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationJustEatClientLogRequestsInputSchema;
+  outputSchema = getIntegrationJustEatClientLogRequestsResponseSchema;
+  querySchema = getIntegrationJustEatClientLogRequestsQuerySchema;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId, options) {
+    super(void 0, options);
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/client_log_requests`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z75.array(integrationClientLogRequestSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination18(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/justeat/GetIntegrationJustEatDetails.ts
+import { AbstractApiRequest as AbstractApiRequest70 } from "@deliverart/sdk-js-core";
+import { z as z76 } from "zod";
+var getIntegrationJustEatDetailsInputSchema = z76.undefined();
+var getIntegrationJustEatDetailsResponseSchema = integrationJustEatDetailsSchema;
+var GetIntegrationJustEatDetails = class extends AbstractApiRequest70 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationJustEatDetailsInputSchema;
+  outputSchema = getIntegrationJustEatDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId) {
+    super();
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}`;
+  }
+};
+
+// src/requests/services/justeat/GetIntegrationJustEatList.ts
+import { AbstractApiRequest as AbstractApiRequest71 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema19,
+  responseToPagination as responseToPagination19
+} from "@deliverart/sdk-js-global-types";
+import { z as z77 } from "zod";
+var getIntegrationJustEatListQuerySchema = integrationsJustEatQuerySchema.omit({
+  service: true
+});
+var getIntegrationJustEatListResponseSchema = createPaginatedSchema19(integrationJustEatSchema);
+var getIntegrationJustEatListInputSchema = z77.undefined();
+var GetIntegrationJustEatList = class extends AbstractApiRequest71 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationJustEatListInputSchema;
+  outputSchema = getIntegrationJustEatListResponseSchema;
+  querySchema = getIntegrationJustEatListQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/integrations/justeat";
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z77.array(integrationJustEatSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination19(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/justeat/GetIntegrationJustEatMenuVersionDetails.ts
+import { AbstractApiRequest as AbstractApiRequest72 } from "@deliverart/sdk-js-core";
+import { z as z78 } from "zod";
+var getIntegrationJustEatMenuVersionDetailsInputSchema = z78.undefined();
+var getIntegrationJustEatMenuVersionDetailsResponseSchema = menuVersionDetailsSchema;
+var GetIntegrationJustEatMenuVersionDetails = class extends AbstractApiRequest72 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationJustEatMenuVersionDetailsInputSchema;
+  outputSchema = getIntegrationJustEatMenuVersionDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  versionId;
+  constructor(integrationJustEatId, versionId) {
+    super();
+    this.integrationJustEatId = integrationJustEatId;
+    this.versionId = versionId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/menu_versions/${this.versionId}`;
+  }
+};
+
+// src/requests/services/justeat/GetIntegrationJustEatMenuVersions.ts
+import { AbstractApiRequest as AbstractApiRequest73 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema20,
+  responseToPagination as responseToPagination20
+} from "@deliverart/sdk-js-global-types";
+import { z as z79 } from "zod";
+var getIntegrationJustEatMenuVersionsQuerySchema = z79.object({
+  page: z79.number().optional()
+});
+var getIntegrationJustEatMenuVersionsResponseSchema = createPaginatedSchema20(menuVersionSchema);
+var getIntegrationJustEatMenuVersionsInputSchema = z79.undefined();
+var GetIntegrationJustEatMenuVersions = class extends AbstractApiRequest73 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationJustEatMenuVersionsInputSchema;
+  outputSchema = getIntegrationJustEatMenuVersionsResponseSchema;
+  querySchema = getIntegrationJustEatMenuVersionsQuerySchema;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId, options) {
+    super(void 0, options);
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/menu_versions`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z79.array(menuVersionSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination20(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/justeat/GetIntegrationJustEatSyncMenuProcessDetails.ts
+import { AbstractApiRequest as AbstractApiRequest74 } from "@deliverart/sdk-js-core";
+import { z as z80 } from "zod";
+var getIntegrationJustEatSyncMenuProcessDetailsInputSchema = z80.undefined();
+var getIntegrationJustEatSyncMenuProcessDetailsResponseSchema = integrationJustEatSyncMenuProcessDetailsSchema;
+var GetIntegrationJustEatSyncMenuProcessDetails = class extends AbstractApiRequest74 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationJustEatSyncMenuProcessDetailsInputSchema;
+  outputSchema = getIntegrationJustEatSyncMenuProcessDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  processId;
+  constructor(integrationJustEatId, processId) {
+    super();
+    this.integrationJustEatId = integrationJustEatId;
+    this.processId = processId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/sync_menu_processes/${this.processId}`;
+  }
+};
+
+// src/requests/services/justeat/GetIntegrationJustEatSyncMenuProcesses.ts
+import { AbstractApiRequest as AbstractApiRequest75 } from "@deliverart/sdk-js-core";
+import {
+  createPaginatedSchema as createPaginatedSchema21,
+  responseToPagination as responseToPagination21
+} from "@deliverart/sdk-js-global-types";
+import { z as z81 } from "zod";
+var getIntegrationJustEatSyncMenuProcessesQuerySchema = z81.object({
+  page: z81.number().optional()
+});
+var getIntegrationJustEatSyncMenuProcessesResponseSchema = createPaginatedSchema21(
+  integrationJustEatSyncMenuProcessSchema
+);
+var getIntegrationJustEatSyncMenuProcessesInputSchema = z81.undefined();
+var GetIntegrationJustEatSyncMenuProcesses = class extends AbstractApiRequest75 {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getIntegrationJustEatSyncMenuProcessesInputSchema;
+  outputSchema = getIntegrationJustEatSyncMenuProcessesResponseSchema;
+  querySchema = getIntegrationJustEatSyncMenuProcessesQuerySchema;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId, options) {
+    super(void 0, options);
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/sync_menu_processes`;
+  }
+  parseResponse(data, rawResponse) {
+    const integrations = z81.array(integrationJustEatSyncMenuProcessSchema).parse(data);
+    return this.validateOutput({
+      data: integrations,
+      pagination: responseToPagination21(rawResponse)
+    });
+  }
+};
+
+// src/requests/services/justeat/IntegrationJustEatSyncMenu.ts
+import { AbstractApiRequest as AbstractApiRequest76 } from "@deliverart/sdk-js-core";
+import { z as z82 } from "zod";
+var integrationJustEatSyncMenuInputSchema = z82.undefined();
+var integrationJustEatSyncMenuResponseSchema = z82.undefined();
+var IntegrationJustEatSyncMenu = class extends AbstractApiRequest76 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationJustEatSyncMenuInputSchema;
+  outputSchema = integrationJustEatSyncMenuResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId) {
+    super();
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/sync/menu`;
+  }
+};
+
+// src/requests/services/justeat/IntegrationJustEatSyncOpeningTimes.ts
+import { AbstractApiRequest as AbstractApiRequest77 } from "@deliverart/sdk-js-core";
+import { z as z83 } from "zod";
+var integrationJustEatSyncOpeningHoursInputSchema = z83.undefined();
+var integrationJustEatSyncOpeningHoursResponseSchema = z83.undefined();
+var IntegrationJustEatSyncOpeningTimes = class extends AbstractApiRequest77 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = integrationJustEatSyncOpeningHoursInputSchema;
+  outputSchema = integrationJustEatSyncOpeningHoursResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId) {
+    super();
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/sync/opening_times`;
+  }
+};
+
+// src/requests/services/justeat/UpdateIntegrationJustEat.ts
+import { AbstractApiRequest as AbstractApiRequest78 } from "@deliverart/sdk-js-core";
+var updateIntegrationJustEatInputSchema = integrationJustEatEditableFieldsSchema;
+var updateIntegrationJustEatResponseSchema = integrationJustEatDetailsSchema;
+var UpdateIntegrationJustEat = class extends AbstractApiRequest78 {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateIntegrationJustEatInputSchema;
+  outputSchema = updateIntegrationJustEatResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId, input) {
+    super(input);
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}`;
+  }
+};
+
+// src/requests/services/justeat/UpdateIntegrationJustEatRestaurantStatus.ts
+import { AbstractApiRequest as AbstractApiRequest79 } from "@deliverart/sdk-js-core";
+import { z as z84 } from "zod";
+var updateIntegrationJustEatRestaurantStatusInputSchema = z84.object({
+  status: integrationJustEatRestaurantStatusSchema
+});
+var updateIntegrationJustEatRestaurantStatusResponseSchema = integrationJustEatDetailsSchema;
+var UpdateIntegrationJustEatRestaurantStatus = class extends AbstractApiRequest79 {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = updateIntegrationJustEatRestaurantStatusInputSchema;
+  outputSchema = updateIntegrationJustEatRestaurantStatusResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationJustEatId;
+  constructor(integrationJustEatId, input) {
+    super(input);
+    this.integrationJustEatId = integrationJustEatId;
+  }
+  getPath() {
+    return `/integrations/justeat/${this.integrationJustEatId}/restaurant/status`;
+  }
+};
+
+// src/requests/UpdateIntegration.ts
+import { AbstractApiRequest as AbstractApiRequest80 } from "@deliverart/sdk-js-core";
+var updateIntegrationInputSchema = writableIntegrationSchema.partial();
+var updateIntegrationResponseSchema = integrationDetailsSchema;
+var UpdateIntegration = class extends AbstractApiRequest80 {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updateIntegrationInputSchema;
+  outputSchema = updateIntegrationResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  integrationId;
+  constructor(integrationId, input) {
+    super(input);
+    this.integrationId = integrationId;
+  }
+  getPath() {
+    return `/integrations/${this.integrationId}`;
+  }
+};
+export {
+  ActivateIntegrationActivationRequest,
+  AnnotateIntegrationActivationRequest,
+  CancelIntegrationCancellationRequest,
+  CreateIntegrationActivationRequest,
+  CreateIntegrationCancellationRequest,
+  CreateIntegrationCassaInCloud,
+  CreateIntegrationDeliveroo,
+  CreateIntegrationGlovo,
+  CreateIntegrationJustEat,
+  DeleteIntegration,
+  DeleteIntegrationActivationRequest,
+  DeleteIntegrationCancellationRequest,
+  DeleteIntegrationCassaInCloud,
+  DeleteIntegrationDeliveroo,
+  DeleteIntegrationGlovo,
+  DeleteIntegrationJustEat,
+  GetIntegrationActivationRequestDetails,
+  GetIntegrationActivationRequests,
+  GetIntegrationCancellationRequestDetails,
+  GetIntegrationCancellationRequests,
+  GetIntegrationCassaInCloudClientLogRequestDetails,
+  GetIntegrationCassaInCloudClientLogRequests,
+  GetIntegrationCassaInCloudDetails,
+  GetIntegrationCassaInCloudList,
+  GetIntegrationCassaInCloudSyncMenuProcessDetails,
+  GetIntegrationCassaInCloudSyncMenuProcesses,
+  GetIntegrationCassaInCloudWebHookEventDetails,
+  GetIntegrationCassaInCloudWebHookEvents,
+  GetIntegrationDeliverooClientLogRequestDetails,
+  GetIntegrationDeliverooClientLogRequests,
+  GetIntegrationDeliverooDetails,
+  GetIntegrationDeliverooList,
+  GetIntegrationDeliverooMenuVersionDetails,
+  GetIntegrationDeliverooMenuVersions,
+  GetIntegrationDeliverooSyncMenuProcessDetails,
+  GetIntegrationDeliverooSyncMenuProcesses,
+  GetIntegrationDeliverooWebhookEventDetails,
+  GetIntegrationDeliverooWebhookEvents,
+  GetIntegrationDetails,
+  GetIntegrationGlovoClientLogRequestDetails,
+  GetIntegrationGlovoClientLogRequests,
+  GetIntegrationGlovoDetails,
+  GetIntegrationGlovoList,
+  GetIntegrationGlovoMenuUpdateDetails,
+  GetIntegrationGlovoMenuUpdates,
+  GetIntegrationGlovoMenuVersionDetails,
+  GetIntegrationGlovoMenuVersions,
+  GetIntegrationGlovoWebhookEventDetails,
+  GetIntegrationGlovoWebhookEvents,
+  GetIntegrationJustEatClientLogRequestDetails,
+  GetIntegrationJustEatClientLogRequests,
+  GetIntegrationJustEatDetails,
+  GetIntegrationJustEatList,
+  GetIntegrationJustEatMenuVersionDetails,
+  GetIntegrationJustEatMenuVersions,
+  GetIntegrationJustEatSyncMenuProcessDetails,
+  GetIntegrationJustEatSyncMenuProcesses,
+  GetIntegrations,
+  IntegrationCassaInCloudSyncCustomers,
+  IntegrationCassaInCloudSyncOrganizations,
+  IntegrationCassaInCloudSyncProducts,
+  IntegrationCassaInCloudSyncSalesModes,
+  IntegrationCassaInCloudSyncStock,
+  IntegrationCassaInCloudSyncTimetables,
+  IntegrationDeliverooSyncMenu,
+  IntegrationDeliverooSyncOpeningHours,
+  IntegrationGlovoSyncMenu,
+  IntegrationJustEatSyncMenu,
+  IntegrationJustEatSyncOpeningTimes,
+  RespondIntegrationActivationRequest,
+  SendIntegrationActivationRequestToPartner,
+  UpdateIntegration,
+  UpdateIntegrationActivationRequest,
+  UpdateIntegrationCassaInCloud,
+  UpdateIntegrationDeliveroo,
+  UpdateIntegrationDeliverooSiteStatus,
+  UpdateIntegrationGlovo,
+  UpdateIntegrationGlovoStoreStatus,
+  UpdateIntegrationJustEat,
+  UpdateIntegrationJustEatRestaurantStatus,
+  activatableIntegrationBaseSchema,
+  activatableIntegrationHealthStatusSchema,
+  activatableIntegrationHealthStatuses,
+  activatableIntegrationSchema,
+  activatableIntegrationStatusSchema,
+  activatableIntegrationStatuses,
+  activateIntegrationActivationRequestInputSchema,
+  activateIntegrationActivationRequestResponseSchema,
+  annotateIntegrationActivationRequestInputSchema,
+  annotateIntegrationActivationRequestResponseSchema,
+  cancelIntegrationCancellationRequestInputSchema,
+  cancelIntegrationCancellationRequestResponseSchema,
+  clientLogRequestQuerySchema,
+  createIntegrationActivationRequestInputSchema,
+  createIntegrationActivationRequestResponseSchema,
+  createIntegrationCancellationRequestInputSchema,
+  createIntegrationCancellationRequestResponseSchema,
+  createIntegrationCassaInCloudInputSchema,
+  createIntegrationCassaInCloudResponseSchema,
+  createIntegrationDeliverooInputSchema,
+  createIntegrationDeliverooResponseSchema,
+  createIntegrationGlovoInputSchema,
+  createIntegrationGlovoResponseSchema,
+  createIntegrationJustEatInputSchema,
+  createIntegrationJustEatResponseSchema,
+  deleteIntegrationActivationRequestInputSchema,
+  deleteIntegrationActivationRequestResponseSchema,
+  deleteIntegrationCancellationRequestInputSchema,
+  deleteIntegrationCancellationRequestResponseSchema,
+  deleteIntegrationCassaInCloudInputSchema,
+  deleteIntegrationCassaInCloudResponseSchema,
+  deleteIntegrationDeliverooInputSchema,
+  deleteIntegrationDeliverooResponseSchema,
+  deleteIntegrationGlovoInputSchema,
+  deleteIntegrationGlovoResponseSchema,
+  deleteIntegrationInputSchema,
+  deleteIntegrationJustEatInputSchema,
+  deleteIntegrationJustEatResponseSchema,
+  deleteIntegrationResponseSchema,
+  getIntegrationActivationRequestDetailsInputSchema,
+  getIntegrationActivationRequestDetailsResponseSchema,
+  getIntegrationActivationRequestsInputSchema,
+  getIntegrationActivationRequestsQuerySchema,
+  getIntegrationActivationRequestsResponseSchema,
+  getIntegrationCancellationRequestDetailsInputSchema,
+  getIntegrationCancellationRequestDetailsResponseSchema,
+  getIntegrationCancellationRequestsInputSchema,
+  getIntegrationCancellationRequestsQuerySchema,
+  getIntegrationCancellationRequestsResponseSchema,
+  getIntegrationCassaInCloudClientLogRequestDetailsInputSchema,
+  getIntegrationCassaInCloudClientLogRequestDetailsResponseSchema,
+  getIntegrationCassaInCloudClientLogRequestsInputSchema,
+  getIntegrationCassaInCloudClientLogRequestsQuerySchema,
+  getIntegrationCassaInCloudClientLogRequestsResponseSchema,
+  getIntegrationCassaInCloudDetailsInputSchema,
+  getIntegrationCassaInCloudDetailsResponseSchema,
+  getIntegrationCassaInCloudListInputSchema,
+  getIntegrationCassaInCloudListQuerySchema,
+  getIntegrationCassaInCloudListResponseSchema,
+  getIntegrationCassaInCloudSyncMenuProcessDetailsInputSchema,
+  getIntegrationCassaInCloudSyncMenuProcessDetailsResponseSchema,
+  getIntegrationCassaInCloudSyncMenuProcessesInputSchema,
+  getIntegrationCassaInCloudSyncMenuProcessesQuerySchema,
+  getIntegrationCassaInCloudSyncMenuProcessesResponseSchema,
+  getIntegrationCassaInCloudWebHookEventDetailsInputSchema,
+  getIntegrationCassaInCloudWebHookEventDetailsResponseSchema,
+  getIntegrationCassaInCloudWebHookEventsInputSchema,
+  getIntegrationCassaInCloudWebHookEventsQuerySchema,
+  getIntegrationCassaInCloudWebHookEventsResponseSchema,
+  getIntegrationDeliverooClientLogRequestDetailsInputSchema,
+  getIntegrationDeliverooClientLogRequestDetailsResponseSchema,
+  getIntegrationDeliverooClientLogRequestsInputSchema,
+  getIntegrationDeliverooClientLogRequestsQuerySchema,
+  getIntegrationDeliverooClientLogRequestsResponseSchema,
+  getIntegrationDeliverooDetailsInputSchema,
+  getIntegrationDeliverooDetailsResponseSchema,
+  getIntegrationDeliverooListInputSchema,
+  getIntegrationDeliverooListQuerySchema,
+  getIntegrationDeliverooListResponseSchema,
+  getIntegrationDeliverooMenuVersionDetailsInputSchema,
+  getIntegrationDeliverooMenuVersionDetailsResponseSchema,
+  getIntegrationDeliverooMenuVersionsInputSchema,
+  getIntegrationDeliverooMenuVersionsQuerySchema,
+  getIntegrationDeliverooMenuVersionsResponseSchema,
+  getIntegrationDeliverooSyncMenuProcessDetailsInputSchema,
+  getIntegrationDeliverooSyncMenuProcessDetailsResponseSchema,
+  getIntegrationDeliverooSyncMenuProcessesInputSchema,
+  getIntegrationDeliverooSyncMenuProcessesQuerySchema,
+  getIntegrationDeliverooSyncMenuProcessesResponseSchema,
+  getIntegrationDeliverooWebhookEventDetailsInputSchema,
+  getIntegrationDeliverooWebhookEventDetailsResponseSchema,
+  getIntegrationDeliverooWebhookEventsInputSchema,
+  getIntegrationDeliverooWebhookEventsQuerySchema,
+  getIntegrationDeliverooWebhookEventsResponseSchema,
+  getIntegrationDetailsInputSchema,
+  getIntegrationDetailsResponseSchema,
+  getIntegrationGlovoClientLogRequestDetailsInputSchema,
+  getIntegrationGlovoClientLogRequestDetailsResponseSchema,
+  getIntegrationGlovoClientLogRequestsInputSchema,
+  getIntegrationGlovoClientLogRequestsQuerySchema,
+  getIntegrationGlovoClientLogRequestsResponseSchema,
+  getIntegrationGlovoDetailsInputSchema,
+  getIntegrationGlovoDetailsResponseSchema,
+  getIntegrationGlovoListInputSchema,
+  getIntegrationGlovoListQuerySchema,
+  getIntegrationGlovoListResponseSchema,
+  getIntegrationGlovoMenuUpdateDetailsInputSchema,
+  getIntegrationGlovoMenuUpdateDetailsResponseSchema,
+  getIntegrationGlovoMenuUpdatesInputSchema,
+  getIntegrationGlovoMenuUpdatesQuerySchema,
+  getIntegrationGlovoMenuUpdatesResponseSchema,
+  getIntegrationGlovoMenuVersionDetailsInputSchema,
+  getIntegrationGlovoMenuVersionDetailsResponseSchema,
+  getIntegrationGlovoMenuVersionsInputSchema,
+  getIntegrationGlovoMenuVersionsQuerySchema,
+  getIntegrationGlovoMenuVersionsResponseSchema,
+  getIntegrationGlovoWebhookEventDetailsInputSchema,
+  getIntegrationGlovoWebhookEventDetailsResponseSchema,
+  getIntegrationGlovoWebhookEventsInputSchema,
+  getIntegrationGlovoWebhookEventsQuerySchema,
+  getIntegrationGlovoWebhookEventsResponseSchema,
+  getIntegrationJustEatClientLogRequestDetailsInputSchema,
+  getIntegrationJustEatClientLogRequestDetailsResponseSchema,
+  getIntegrationJustEatClientLogRequestsInputSchema,
+  getIntegrationJustEatClientLogRequestsQuerySchema,
+  getIntegrationJustEatClientLogRequestsResponseSchema,
+  getIntegrationJustEatDetailsInputSchema,
+  getIntegrationJustEatDetailsResponseSchema,
+  getIntegrationJustEatListInputSchema,
+  getIntegrationJustEatListQuerySchema,
+  getIntegrationJustEatListResponseSchema,
+  getIntegrationJustEatMenuVersionDetailsInputSchema,
+  getIntegrationJustEatMenuVersionDetailsResponseSchema,
+  getIntegrationJustEatMenuVersionsInputSchema,
+  getIntegrationJustEatMenuVersionsQuerySchema,
+  getIntegrationJustEatMenuVersionsResponseSchema,
+  getIntegrationJustEatSyncMenuProcessDetailsInputSchema,
+  getIntegrationJustEatSyncMenuProcessDetailsResponseSchema,
+  getIntegrationJustEatSyncMenuProcessesInputSchema,
+  getIntegrationJustEatSyncMenuProcessesQuerySchema,
+  getIntegrationJustEatSyncMenuProcessesResponseSchema,
+  getIntegrationsInputSchema,
+  getIntegrationsQuerySchema,
+  getIntegrationsResponseSchema,
+  integrationActivationRequestDetailsSchema,
+  integrationActivationRequestSchema,
+  integrationBaseSchema,
+  integrationCancellationRequestDetailsSchema,
+  integrationCancellationRequestNullablePathSchema,
+  integrationCancellationRequestPathSchema,
+  integrationCancellationRequestSchema,
+  integrationCancellationRequestStatusSchema,
+  integrationCancellationRequestStatuses,
+  integrationCassaInCloudDataSchema,
+  integrationCassaInCloudDirectionSchema,
+  integrationCassaInCloudDirections,
+  integrationCassaInCloudNullablePathSchema,
+  integrationCassaInCloudPathSchema,
+  integrationCassaInCloudProductChannelSchema,
+  integrationCassaInCloudProductChannels,
+  integrationCassaInCloudSyncCustomersInputSchema,
+  integrationCassaInCloudSyncCustomersResponseSchema,
+  integrationCassaInCloudSyncMenuErrorLogNullablePathSchema,
+  integrationCassaInCloudSyncMenuErrorLogPathSchema,
+  integrationCassaInCloudSyncOrganizationsInputSchema,
+  integrationCassaInCloudSyncOrganizationsResponseSchema,
+  integrationCassaInCloudSyncProductsInputSchema,
+  integrationCassaInCloudSyncProductsResponseSchema,
+  integrationCassaInCloudSyncSalesModesInputSchema,
+  integrationCassaInCloudSyncSalesModesResponseSchema,
+  integrationCassaInCloudSyncStockInputSchema,
+  integrationCassaInCloudSyncStockResponseSchema,
+  integrationCassaInCloudSyncTimetablesInputSchema,
+  integrationCassaInCloudSyncTimetablesResponseSchema,
+  integrationCassaInCloudWebHookEventEntities,
+  integrationCassaInCloudWebHookEventEntitySchema,
+  integrationCassaInCloudWebHookEventEventSchema,
+  integrationCassaInCloudWebHookEventEvents,
+  integrationClientLogRequestDetailsSchema,
+  integrationClientLogRequestMethodSchema,
+  integrationClientLogRequestMethods,
+  integrationClientLogRequestSchema,
+  integrationDeliverooDataSchema,
+  integrationDeliverooNullablePathSchema,
+  integrationDeliverooPathSchema,
+  integrationDeliverooSiteStatusSchema,
+  integrationDeliverooSiteStatuses,
+  integrationDeliverooSyncMenuInputSchema,
+  integrationDeliverooSyncMenuProcessModeSchema,
+  integrationDeliverooSyncMenuProcessModes,
+  integrationDeliverooSyncMenuResponseSchema,
+  integrationDeliverooSyncOpeningHoursInputSchema,
+  integrationDeliverooSyncOpeningHoursResponseSchema,
+  integrationDeliverooWebhookEventTypeSchema,
+  integrationDeliverooWebhookEventTypes,
+  integrationDeliveryProviderCommonSchema,
+  integrationDetailsFieldsSchema,
+  integrationGlovoDataSchema,
+  integrationGlovoMenuUpdateStatusSchema,
+  integrationGlovoMenuUpdateStatuses,
+  integrationGlovoNullablePathSchema,
+  integrationGlovoPathSchema,
+  integrationGlovoStoreStatusSchema,
+  integrationGlovoStoreStatuses,
+  integrationGlovoSyncMenuInputSchema,
+  integrationGlovoSyncMenuResponseSchema,
+  integrationGlovoWebhookEventTypeSchema,
+  integrationGlovoWebhookEventTypes,
+  integrationJustEatDataSchema,
+  integrationJustEatNullablePathSchema,
+  integrationJustEatPathSchema,
+  integrationJustEatRestaurantStatusSchema,
+  integrationJustEatRestaurantStatuses,
+  integrationJustEatSyncMenuInputSchema,
+  integrationJustEatSyncMenuResponseSchema,
+  integrationJustEatSyncOpeningHoursInputSchema,
+  integrationJustEatSyncOpeningHoursResponseSchema,
+  integrationJustEatSyncTypeSchema,
+  integrationJustEatSyncTypes,
+  integrationNullablePathSchema,
+  integrationPathSchema,
+  integrationPathSchemas,
+  integrationProviderSchema,
+  integrationProviders,
+  integrationServiceDataSchema,
+  integrationServiceSchema,
+  integrationServices,
+  integrationStatusSchema,
+  integrationStatuses,
+  menuVersionDetailsSchema,
+  menuVersionSchema,
+  respondIntegrationActivationRequestInputSchema,
+  respondIntegrationActivationRequestResponseSchema,
+  sendIntegrationActivationRequestToPartnerInputSchema,
+  sendIntegrationActivationRequestToPartnerResponseSchema,
+  updateIntegrationActivationRequestInputSchema,
+  updateIntegrationActivationRequestResponseSchema,
+  updateIntegrationCassaInCloudInputSchema,
+  updateIntegrationCassaInCloudResponseSchema,
+  updateIntegrationDeliverooInputSchema,
+  updateIntegrationDeliverooResponseSchema,
+  updateIntegrationDeliverooSiteStatusInputSchema,
+  updateIntegrationDeliverooSiteStatusResponseSchema,
+  updateIntegrationGlovoInputSchema,
+  updateIntegrationGlovoResponseSchema,
+  updateIntegrationGlovoStoreStatusInputSchema,
+  updateIntegrationGlovoStoreStatusResponseSchema,
+  updateIntegrationInputSchema,
+  updateIntegrationJustEatInputSchema,
+  updateIntegrationJustEatResponseSchema,
+  updateIntegrationJustEatRestaurantStatusInputSchema,
+  updateIntegrationJustEatRestaurantStatusResponseSchema,
+  updateIntegrationResponseSchema,
+  writableIntegrationSchema
+};