@deliverart/sdk-js-integration 0.0.5 → 1.2.0

package/src/service-schemas/glovo.ts

@@ -1,153 +0,0 @@
-import {
-  datetimeSchema,
-  sortDirSchema,
-  timestampsFilterSchema,
-} from '@deliverart/sdk-js-global-types'
-import { z } from 'zod'
-
-import {
-  integrationBaseSchema,
-  integrationDeliveryProviderCommonSchema,
-  integrationDetailsFieldsSchema,
-} from '../schemas'
-import {
-  integrationDeliverooPathSchema,
-  integrationGlovoMenuUpdateStatusSchema,
-  integrationGlovoPathSchema,
-  integrationGlovoWebhookEventTypeSchema,
-  integrationServiceSchema,
-  integrationStatusSchema,
-} from '../types'
-
-export const integrationGlovoSchema = integrationBaseSchema
-  .omit({ service: true })
-  .extend(integrationDeliveryProviderCommonSchema.shape)
-  .extend({
-    storeId: z.string(),
-    locale: z.string(),
-    pendingMenuChanges: z.boolean(),
-    service: integrationServiceSchema.extract(['glovo']),
-  })
-export type IntegrationGlovo = z.infer<typeof integrationGlovoSchema>
-
-export const integrationGlovoDetailsSchema = integrationGlovoSchema.extend(
-  integrationDetailsFieldsSchema.shape,
-)
-export type IntegrationGlovoDetails = z.infer<typeof integrationGlovoDetailsSchema>
-
-export const integrationGlovoEditableFieldsSchema = integrationGlovoSchema
-  .pick({
-    name: true,
-    storeId: true,
-    locale: true,
-    skipNegativePrices: true,
-    skipInvalidItem: true,
-    salesMode: true,
-    importTaggedItems: true,
-    tagsForImport: true,
-    provider: true,
-  })
-  .partial()
-export type IntegrationGlovoEditableFields = z.infer<typeof integrationGlovoEditableFieldsSchema>
-
-export const integrationsGlovoQuerySchema = z
-  .object({
-    'order[createdAt]': sortDirSchema.optional(),
-    'order[updatedAt]': sortDirSchema.optional(),
-    'order[latestMenuCheckAt]': sortDirSchema.optional(),
-    'order[latestMenuSyncAt]': sortDirSchema.optional(),
-    name: z.string().optional(),
-    storeId: z.string().optional(),
-    'storeId[]': z.array(z.string()).optional(),
-    status: integrationStatusSchema.optional(),
-    'status[]': z.array(integrationStatusSchema).optional(),
-    connectionId: z.string().optional(),
-    'connectionId[]': z.array(z.string()).optional(),
-    skipInvalidItem: z.coerce.boolean().optional(),
-    isValidMenu: z.coerce.boolean().optional(),
-    'latestMenuCheckAt[before]': z.string().optional(),
-    'latestMenuCheckAt[strictly_before]': z.string().optional(),
-    'latestMenuCheckAt[after]': z.string().optional(),
-    'latestMenuCheckAt[strictly_after]': z.string().optional(),
-    'latestMenuSyncAt[before]': z.string().optional(),
-    'latestMenuSyncAt[strictly_before]': z.string().optional(),
-    'latestMenuSyncAt[after]': z.string().optional(),
-    'latestMenuSyncAt[strictly_after]': z.string().optional(),
-    service: integrationServiceSchema.extract(['glovo']).optional(),
-    page: z.coerce.number().optional(),
-  })
-  .merge(timestampsFilterSchema)
-export type IntegrationsGlovoQueryParams = z.infer<typeof integrationsGlovoQuerySchema>
-
-export const integrationGlovoWebhookEventSchema = z.object({
-  id: z.string(),
-  event: integrationGlovoWebhookEventTypeSchema,
-  body: z.any(),
-  createdAt: datetimeSchema,
-})
-export type IntegrationGlovoWebhookEvent = z.infer<typeof integrationGlovoWebhookEventSchema>
-export const integrationGlovoWebhookEventDetailsSchema = integrationGlovoWebhookEventSchema.extend({
-  integration: integrationGlovoPathSchema,
-})
-export type IntegrationGlovoWebhookEventDetails = z.infer<
-  typeof integrationGlovoWebhookEventDetailsSchema
->
-
-export const integrationGlovoWebhookEventsQueryParamsSchema = z.object({
-  'order[createdAt]': sortDirSchema.optional(),
-  event: integrationGlovoWebhookEventTypeSchema.optional(),
-  'event[]': z.array(integrationGlovoWebhookEventTypeSchema).optional(),
-  'createdAt[before]': z.string().optional(),
-  'createdAt[strictly_before]': z.string().optional(),
-  'createdAt[after]': z.string().optional(),
-  'createdAt[strictly_after]': z.string().optional(),
-  page: z.coerce.number().optional(),
-})
-export type IntegrationGlovoWebhookEventsQueryParams = z.infer<
-  typeof integrationGlovoWebhookEventsQueryParamsSchema
->
-
-export const integrationGlovoMenuUpdateSchema = z.object({
-  id: z.string(),
-  transactionId: z.string().nullable(),
-  status: integrationGlovoMenuUpdateStatusSchema.nullable(),
-  retryCompleted: z.boolean(),
-  createdAt: datetimeSchema,
-  responseAt: datetimeSchema.nullable(),
-  latestCheckAt: datetimeSchema.nullable(),
-})
-export type IntegrationGlovoMenuUpdate = z.infer<typeof integrationGlovoMenuUpdateSchema>
-export const integrationGlovoMenuUpdateDetailsSchema = integrationGlovoMenuUpdateSchema.extend({
-  integration: integrationDeliverooPathSchema,
-  details: z.any().nullable(),
-})
-export type IntegrationGlovoMenuUpdateDetails = z.infer<
-  typeof integrationGlovoMenuUpdateDetailsSchema
->
-
-export const integrationGlovoMenuUpdatesQuerySchema = z.object({
-  'order[createdAt]': sortDirSchema.optional(),
-  'order[responseAt]': sortDirSchema.optional(),
-  'order[latestCheckAt]': sortDirSchema.optional(),
-  retryCompleted: z.coerce.boolean().optional(),
-  transactionId: z.string().optional(),
-  'transactionId[]': z.array(z.string()).optional(),
-  status: integrationGlovoMenuUpdateStatusSchema.optional(),
-  'status[]': z.array(integrationGlovoMenuUpdateStatusSchema).optional(),
-  'createdAt[before]': z.string().optional(),
-  'createdAt[strictly_before]': z.string().optional(),
-  'createdAt[after]': z.string().optional(),
-  'createdAt[strictly_after]': z.string().optional(),
-  'responseAt[before]': z.string().optional(),
-  'responseAt[strictly_before]': z.string().optional(),
-  'responseAt[after]': z.string().optional(),
-  'responseAt[strictly_after]': z.string().optional(),
-  'latestCheckAt[before]': z.string().optional(),
-  'latestCheckAt[strictly_before]': z.string().optional(),
-  'latestCheckAt[after]': z.string().optional(),
-  'latestCheckAt[strictly_after]': z.string().optional(),
-  page: z.coerce.number().optional(),
-})
-export type IntegrationGlovoMenuUpdatesQueryParams = z.infer<
-  typeof integrationGlovoMenuUpdatesQuerySchema
->

package/src/service-schemas/justeat.ts

@@ -1,121 +0,0 @@
-import {
-  datetimeSchema,
-  sortDirSchema,
-  timestampsFilterSchema,
-} from '@deliverart/sdk-js-global-types'
-import { z } from 'zod'
-
-import {
-  integrationBaseSchema,
-  integrationDeliveryProviderCommonSchema,
-  integrationDetailsFieldsSchema,
-} from '../schemas'
-import {
-  integrationJustEatPathSchema,
-  integrationJustEatSyncTypeSchema,
-  integrationServiceSchema,
-  integrationStatusSchema,
-} from '../types'
-
-export const integrationJustEatSchema = integrationBaseSchema
-  .omit({ service: true })
-  .extend(integrationDeliveryProviderCommonSchema.shape)
-  .extend({
-    syncType: integrationJustEatSyncTypeSchema,
-    defaultLanguage: z.string(),
-    restaurantId: z.string(),
-    latestOpeningTimesSyncAt: datetimeSchema.nullable(),
-    service: integrationServiceSchema.extract(['justeat']),
-    autoAcceptOrders: z.boolean(),
-    nextSyncMenuScheduledAt: datetimeSchema.nullable(),
-  })
-export type IntegrationJustEat = z.infer<typeof integrationJustEatSchema>
-
-export const integrationJustEatDetailsSchema = integrationJustEatSchema.extend(
-  integrationDetailsFieldsSchema.shape,
-)
-export type IntegrationJustEatDetails = z.infer<typeof integrationJustEatDetailsSchema>
-
-export const integrationJustEatEditableFieldsSchema = integrationJustEatSchema
-  .pick({
-    name: true,
-    provider: true,
-    syncType: true,
-    defaultLanguage: true,
-    restaurantId: true,
-    skipNegativePrices: true,
-    skipInvalidItem: true,
-    autoAcceptOrders: true,
-    importTaggedItems: true,
-    tagsForImport: true,
-  })
-  .partial()
-export type IntegrationJustEatEditableFields = z.infer<
-  typeof integrationJustEatEditableFieldsSchema
->
-
-export const integrationsJustEatQuerySchema = z
-  .object({
-    'order[createdAt]': sortDirSchema.optional(),
-    'order[updatedAt]': sortDirSchema.optional(),
-    'order[latestMenuCheckAt]': sortDirSchema.optional(),
-    'order[latestMenuSyncAt]': sortDirSchema.optional(),
-    'order[latestOpeningTimesSyncAt]': sortDirSchema.optional(),
-    'order[nextSyncMenuScheduledAt]': sortDirSchema.optional(),
-    name: z.string().optional(),
-    restaurantId: z.string().optional(),
-    'restaurantId[]': z.array(z.string()).optional(),
-    status: integrationStatusSchema.optional(),
-    'status[]': z.array(integrationStatusSchema).optional(),
-    syncType: integrationJustEatPathSchema.optional(),
-    'syncType[]': z.array(integrationJustEatPathSchema).optional(),
-    connectionId: z.string().optional(),
-    'connectionId[]': z.array(z.string()).optional(),
-    skipInvalidItem: z.coerce.boolean().optional(),
-    isValidMenu: z.coerce.boolean().optional(),
-    'latestMenuCheckAt[before]': z.string().optional(),
-    'latestMenuCheckAt[strictly_before]': z.string().optional(),
-    'latestMenuCheckAt[after]': z.string().optional(),
-    'latestMenuCheckAt[strictly_after]': z.string().optional(),
-    'latestMenuSyncAt[before]': z.string().optional(),
-    'latestMenuSyncAt[strictly_before]': z.string().optional(),
-    'latestMenuSyncAt[after]': z.string().optional(),
-    'latestMenuSyncAt[strictly_after]': z.string().optional(),
-    'latestOpeningTimesSyncAt[before]': z.string().optional(),
-    'latestOpeningTimesSyncAt[strictly_before]': z.string().optional(),
-    'latestOpeningTimesSyncAt[after]': z.string().optional(),
-    'latestOpeningTimesSyncAt[strictly_after]': z.string().optional(),
-    'nextSyncMenuScheduledAt[before]': z.string().optional(),
-    'nextSyncMenuScheduledAt[strictly_before]': z.string().optional(),
-    'nextSyncMenuScheduledAt[after]': z.string().optional(),
-    'nextSyncMenuScheduledAt[strictly_after]': z.string().optional(),
-    service: integrationServiceSchema.extract(['justeat']).optional(),
-    page: z.coerce.number().optional(),
-  })
-  .merge(timestampsFilterSchema)
-export type IntegrationsJustEatQueryParams = z.infer<typeof integrationsJustEatQuerySchema>
-
-export const integrationJustEatSyncMenuProcessSchema = z.object({
-  id: z.string(),
-  ingestionSucceeded: z.boolean().nullable(),
-  error: z.any().nullable(),
-  createdAt: datetimeSchema,
-})
-export type IntegrationJustEatSyncMenuProcess = z.infer<
-  typeof integrationJustEatSyncMenuProcessSchema
->
-export const integrationJustEatSyncMenuProcessDetailsSchema =
-  integrationJustEatSyncMenuProcessSchema.extend({
-    integration: integrationJustEatPathSchema,
-  })
-export type IntegrationJustEatSyncMenuProcessDetails = z.infer<
-  typeof integrationJustEatSyncMenuProcessDetailsSchema
->
-
-export const integrationJustEatSyncMenuProcessesQuerySchema = z.object({
-  'order[createdAt]': sortDirSchema.optional(),
-  page: z.coerce.number().optional(),
-})
-export type IntegrationJustEatSyncMenuProcessesQueryParams = z.infer<
-  typeof integrationJustEatSyncMenuProcessesQuerySchema
->

package/src/types.ts

@@ -1,296 +0,0 @@
-import { z } from 'zod'
-
-export const integrationStatuses = ['pending', 'active', 'deleting'] as const
-export const integrationStatusSchema = z.enum(integrationStatuses)
-export type IntegrationStatus = z.infer<typeof integrationStatusSchema>
-
-export const integrationProviders = ['deliverart', 'cassa_in_cloud'] as const
-export const integrationProviderSchema = z.enum(integrationProviders)
-export type IntegrationProvider = z.infer<typeof integrationProviderSchema>
-
-export const integrationServices = ['deliveroo', 'justeat', 'glovo', 'cassa_in_cloud'] as const
-export const integrationServiceSchema = z.enum(integrationServices)
-export type IntegrationService = z.infer<typeof integrationServiceSchema>
-
-export const integrationClientLogRequestMethods = ['DELETE', 'GET', 'PATCH', 'POST', 'PUT'] as const
-export const integrationClientLogRequestMethodSchema = z.enum(integrationClientLogRequestMethods)
-export type IntegrationClientLogRequestMethod = z.infer<
-  typeof integrationClientLogRequestMethodSchema
->
-
-export const integrationJustEatSyncTypes = ['ALL', 'DELIVERY', 'TAKE_AWAY'] as const
-export const integrationJustEatSyncTypeSchema = z.enum(integrationJustEatSyncTypes)
-export type IntegrationJustEatSyncType = z.infer<typeof integrationJustEatSyncTypeSchema>
-
-export const integrationJustEatRestaurantStatuses = ['OPEN', 'CLOSED'] as const
-export const integrationJustEatRestaurantStatusSchema = z.enum(integrationJustEatRestaurantStatuses)
-export type IntegrationJustEatRestaurantStatus = z.infer<
-  typeof integrationJustEatRestaurantStatusSchema
->
-
-export const integrationDeliverooSiteStatuses = ['OPEN', 'CLOSED'] as const
-export const integrationDeliverooSiteStatusSchema = z.enum(integrationDeliverooSiteStatuses)
-export type IntegrationDeliverooSiteStatus = z.infer<typeof integrationDeliverooSiteStatusSchema>
-
-export const integrationDeliverooSyncMenuProcessModes = ['menu', 'item_availabilities'] as const
-export const integrationDeliverooSyncMenuProcessModeSchema = z.enum(
-  integrationDeliverooSyncMenuProcessModes,
-)
-export type IntegrationDeliverooSyncMenuProcessMode = z.infer<
-  typeof integrationDeliverooSyncMenuProcessModeSchema
->
-
-export const integrationDeliverooWebhookEventTypes = [
-  'order.new',
-  'order.status_update',
-  'rider.status_update',
-  'menu.upload_result',
-] as const
-export const integrationDeliverooWebhookEventTypeSchema = z.enum(
-  integrationDeliverooWebhookEventTypes,
-)
-export type IntegrationDeliverooWebhookEventType = z.infer<
-  typeof integrationDeliverooWebhookEventTypeSchema
->
-
-export const integrationGlovoMenuUpdateStatuses = [
-  'SUCCESS',
-  'PROCESSING',
-  'FETCH_MENU_INVALID_PAYLOAD',
-  'FETCH_MENU_SERVER_ERROR',
-  'FETCH_MENU_UNAUTHORIZED',
-  'NOT_PROCESSED',
-  'LIMIT_EXCEEDED',
-  'GLOVO_ERROR',
-  'SCHEDULE_CATALOG_DISABLED',
-] as const
-export const integrationGlovoMenuUpdateStatusSchema = z.enum(integrationGlovoMenuUpdateStatuses)
-export type IntegrationGlovoMenuUpdateStatus = z.infer<
-  typeof integrationGlovoMenuUpdateStatusSchema
->
-
-export const integrationGlovoStoreStatuses = ['OPEN', 'CLOSED'] as const
-export const integrationGlovoStoreStatusSchema = z.enum(integrationGlovoStoreStatuses)
-export type IntegrationGlovoStoreStatus = z.infer<typeof integrationGlovoStoreStatusSchema>
-
-export const integrationGlovoWebhookEventTypes = ['order.dispatched', 'order.cancelled'] as const
-export const integrationGlovoWebhookEventTypeSchema = z.enum(integrationGlovoWebhookEventTypes)
-export type IntegrationGlovoWebhookEventType = z.infer<
-  typeof integrationGlovoWebhookEventTypeSchema
->
-
-export const integrationCassaInCloudDirections = [
-  'EXTERNAL_TO_INTERNAL',
-  'INTERNAL_TO_EXTERNAL',
-] as const
-export const integrationCassaInCloudDirectionSchema = z.enum(integrationCassaInCloudDirections)
-export type IntegrationCassaInCloudDirection = z.infer<
-  typeof integrationCassaInCloudDirectionSchema
->
-
-export const integrationCassaInCloudProductChannels = [
-  'RISTO',
-  'SALE',
-  'ECOMMERCE',
-  'MOBILE_COMMERCE',
-  'SELF_ORDER',
-  'KIOSK',
-] as const
-export const integrationCassaInCloudProductChannelSchema = z.enum(
-  integrationCassaInCloudProductChannels,
-)
-export type IntegrationCassaInCloudProductChannel = z.infer<
-  typeof integrationCassaInCloudProductChannelSchema
->
-
-export const integrationCassaInCloudWebHookEventEntities = [
-  'BILL',
-  'RECEIPT',
-  'CREDIT_NOTE',
-  'INVOICE',
-  'DDT',
-  'ORDER',
-  'QUOTATION',
-  'RECONCILIATION',
-  'STOCK_MOVEMENT',
-  'CUSTOMER',
-  'ORGANIZATION',
-] as const
-export const integrationCassaInCloudWebHookEventEntitySchema = z.enum(
-  integrationCassaInCloudWebHookEventEntities,
-)
-export type IntegrationCassaInCloudWebHookEventEntity = z.infer<
-  typeof integrationCassaInCloudWebHookEventEntitySchema
->
-
-export const integrationCassaInCloudWebHookEventEvents = ['CREATE', 'UPDATE', 'DELETE'] as const
-export const integrationCassaInCloudWebHookEventEventSchema = z.enum(
-  integrationCassaInCloudWebHookEventEvents,
-)
-export type IntegrationCassaInCloudWebHookEventEvent = z.infer<
-  typeof integrationCassaInCloudWebHookEventEventSchema
->
-
-function createIntegrationPathSchemas(service: IntegrationService) {
-  const regex = new RegExp(
-    `^/integrations/${service}/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`,
-  )
-
-  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 }
-}
-
-function createIntegrationMenuVersionPathSchemas(service: IntegrationService) {
-  const regex = new RegExp(
-    `^/integrations/${service}/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/menu_versions/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`,
-  )
-
-  const pathSchema = z.string().refine(val => regex.test(val), {
-    message: `Invalid integration ${service} menu version path format`,
-  })
-
-  const nullablePathSchema = z
-    .string()
-    .nullable()
-    .refine(val => val == null || regex.test(val), {
-      message: `Invalid integration ${service} menu version path format`,
-    })
-
-  return { pathSchema, nullablePathSchema }
-}
-
-export const integrationPathSchemas = Object.fromEntries(
-  integrationServices.map(service => [service, createIntegrationPathSchemas(service)]),
-) as Record<IntegrationService, ReturnType<typeof createIntegrationPathSchemas>>
-
-export const integrationMenuVersionPathSchemas = Object.fromEntries(
-  integrationServices.map(service => [service, createIntegrationMenuVersionPathSchemas(service)]),
-) as Record<IntegrationService, ReturnType<typeof createIntegrationMenuVersionPathSchemas>>
-
-export const integrationDeliverooPathSchema = integrationPathSchemas.deliveroo.pathSchema
-export const integrationDeliverooNullablePathSchema =
-  integrationPathSchemas.deliveroo.nullablePathSchema
-export type IntegrationDeliverooPath = z.infer<typeof integrationDeliverooPathSchema>
-export type IntegrationDeliverooNullablePath = z.infer<
-  typeof integrationDeliverooNullablePathSchema
->
-
-export const integrationDeliverooMenuVersionPathSchema =
-  integrationMenuVersionPathSchemas.deliveroo.pathSchema
-export const integrationDeliverooMenuVersionNullablePathSchema =
-  integrationMenuVersionPathSchemas.deliveroo.nullablePathSchema
-export type IntegrationDeliverooMenuVersionPath = z.infer<
-  typeof integrationDeliverooMenuVersionPathSchema
->
-export type IntegrationDeliverooMenuVersionNullablePath = z.infer<
-  typeof integrationDeliverooMenuVersionNullablePathSchema
->
-
-export const integrationGlovoPathSchema = integrationPathSchemas.glovo.pathSchema
-export const integrationGlovoNullablePathSchema = integrationPathSchemas.glovo.nullablePathSchema
-export type IntegrationGlovoPath = z.infer<typeof integrationGlovoPathSchema>
-export type IntegrationGlovoNullablePath = z.infer<typeof integrationGlovoNullablePathSchema>
-
-export const integrationGlovoMenuVersionPathSchema =
-  integrationMenuVersionPathSchemas.glovo.pathSchema
-export const integrationGlovoMenuVersionNullablePathSchema =
-  integrationMenuVersionPathSchemas.glovo.nullablePathSchema
-export type IntegrationGlovoMenuVersionPath = z.infer<typeof integrationGlovoMenuVersionPathSchema>
-export type IntegrationGlovoMenuVersionNullablePath = z.infer<
-  typeof integrationGlovoMenuVersionNullablePathSchema
->
-
-export const integrationJustEatPathSchema = integrationPathSchemas.justeat.pathSchema
-export const integrationJustEatNullablePathSchema =
-  integrationPathSchemas.justeat.nullablePathSchema
-export type IntegrationJustEatPath = z.infer<typeof integrationJustEatPathSchema>
-export type IntegrationJustEatNullablePath = z.infer<typeof integrationJustEatNullablePathSchema>
-
-export const integrationJustEatMenuVersionPathSchema =
-  integrationMenuVersionPathSchemas.justeat.pathSchema
-export const integrationJustEatMenuVersionNullablePathSchema =
-  integrationMenuVersionPathSchemas.justeat.nullablePathSchema
-export type IntegrationJustEatMenuVersionPath = z.infer<
-  typeof integrationJustEatMenuVersionPathSchema
->
-export type IntegrationJustEatMenuVersionNullablePath = z.infer<
-  typeof integrationJustEatMenuVersionNullablePathSchema
->
-
-export const integrationCassaInCloudPathSchema = integrationPathSchemas.cassa_in_cloud.pathSchema
-export const integrationCassaInCloudNullablePathSchema =
-  integrationPathSchemas.cassa_in_cloud.nullablePathSchema
-export type IntegrationCassaInCloudPath = z.infer<typeof integrationCassaInCloudPathSchema>
-export type IntegrationCassaInCloudNullablePath = z.infer<
-  typeof integrationCassaInCloudNullablePathSchema
->
-
-export const integrationPathSchema = z
-  .string()
-  .refine(
-    val =>
-      /^\/integrations\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(
-        val,
-      ),
-    {
-      message: 'Invalid integration path format',
-    },
-  )
-export type IntegrationPath = z.infer<typeof integrationPathSchema>
-
-export const integrationNullablePathSchema = z
-  .string()
-  .nullable()
-  .refine(
-    val =>
-      val == null ||
-      /^\/integrations\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(
-        val,
-      ),
-    {
-      message: 'Invalid integration path format',
-    },
-  )
-export type IntegrationNullablePath = z.infer<typeof integrationNullablePathSchema>
-
-export const integrationCassaInCloudSyncMenuErrorLogPathSchema = z
-  .string()
-  .refine(
-    val =>
-      /^\/integrations\/cassa_in_cloud\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\/sync_menu_processes\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\/error_logs\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(
-        val,
-      ),
-    {
-      message: 'Invalid integration path format',
-    },
-  )
-export type IntegrationCassaInCloudSyncMenuErrorLogPath = z.infer<
-  typeof integrationCassaInCloudSyncMenuErrorLogPathSchema
->
-
-export const integrationCassaInCloudSyncMenuErrorLogNullablePathSchema = z
-  .string()
-  .nullable()
-  .refine(
-    val =>
-      val == null ||
-      /^\/integrations\/cassa_in_cloud\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\/sync_menu_processes\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\/error_logs\/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(
-        val,
-      ),
-    {
-      message: 'Invalid integration path format',
-    },
-  )
-export type IntegrationCassaInCloudSyncMenuErrorLogNullablePath = z.infer<
-  typeof integrationCassaInCloudSyncMenuErrorLogNullablePathSchema
->

package/tsconfig.json

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