@kl1/contracts 1.0.16 → 1.0.17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  // src/contract.ts
2
- import { initContract as initContract27 } from "@ts-rest/core";
2
+ import { initContract as initContract28 } from "@ts-rest/core";
3
3
 
4
4
  // src/attribute/index.ts
5
5
  import { initContract } from "@ts-rest/core";
@@ -1196,6 +1196,7 @@ var ContactContractValidationSchema = {
1196
1196
  page: z26.number(),
1197
1197
  pageSize: z26.number(),
1198
1198
  total: z26.number(),
1199
+ lastPage: z26.number(),
1199
1200
  data: z26.array(ContactSchema)
1200
1201
  }
1201
1202
  },
@@ -1266,6 +1267,34 @@ var ContactContractValidationSchema = {
1266
1267
  email: z26.string()
1267
1268
  }),
1268
1269
  response: z26.boolean()
1270
+ },
1271
+ filterContacts: {
1272
+ request: z26.object({
1273
+ page: z26.coerce.number().default(1),
1274
+ pageSize: z26.coerce.number().default(10),
1275
+ keyword: z26.string()
1276
+ }).partial(),
1277
+ response: {
1278
+ page: z26.number(),
1279
+ pageSize: z26.number(),
1280
+ total: z26.number(),
1281
+ lastPage: z26.number(),
1282
+ data: z26.array(ContactSchema)
1283
+ }
1284
+ },
1285
+ addAttachments: {
1286
+ request: z26.object({
1287
+ attributeId: z26.string().uuid(),
1288
+ attachments: z26.array(
1289
+ z26.object({
1290
+ bucketName: z26.string(),
1291
+ fileKey: z26.string(),
1292
+ fileName: z26.string(),
1293
+ fileSize: z26.coerce.number()
1294
+ })
1295
+ ).optional()
1296
+ }),
1297
+ response: CustomFieldSchema
1269
1298
  }
1270
1299
  };
1271
1300
 
@@ -1341,6 +1370,29 @@ var contactContract = initContract7().router(
1341
1370
  },
1342
1371
  summary: "Get all contacts"
1343
1372
  },
1373
+ filterContacts: {
1374
+ method: "GET",
1375
+ path: "/filter",
1376
+ query: ContactContractValidationSchema.filterContacts.request,
1377
+ responses: {
1378
+ 200: DefaultSuccessResponseSchema.extend(
1379
+ ContactContractValidationSchema.filterContacts.response
1380
+ ),
1381
+ 400: z27.object({
1382
+ message: z27.string()
1383
+ }),
1384
+ 409: z27.object({
1385
+ message: z27.string()
1386
+ }),
1387
+ 500: z27.object({
1388
+ message: z27.string()
1389
+ }),
1390
+ 401: DefaultUnauthorizedSchema,
1391
+ 404: DefaultNotFoundSchema,
1392
+ 422: DefaultUnprocessibleSchema
1393
+ },
1394
+ summary: "Get all contacts by filtering with only keyword"
1395
+ },
1344
1396
  update: {
1345
1397
  method: "PATCH",
1346
1398
  path: "/:id",
@@ -1503,6 +1555,32 @@ var contactContract = initContract7().router(
1503
1555
  },
1504
1556
  body: ContactContractValidationSchema.checkContactEmail.request,
1505
1557
  summary: "Check whether a contact owns a email"
1558
+ },
1559
+ addAttachments: {
1560
+ method: "POST",
1561
+ path: "/:id/attachments",
1562
+ pathParams: z27.object({
1563
+ id: z27.string().uuid()
1564
+ }),
1565
+ responses: {
1566
+ 201: DefaultSuccessResponseSchema.extend({
1567
+ message: ContactContractValidationSchema.addAttachments.response
1568
+ }),
1569
+ 400: z27.object({
1570
+ message: z27.string()
1571
+ }),
1572
+ 409: z27.object({
1573
+ message: z27.string()
1574
+ }),
1575
+ 500: z27.object({
1576
+ message: z27.string()
1577
+ }),
1578
+ 401: DefaultUnauthorizedSchema,
1579
+ 404: DefaultNotFoundSchema,
1580
+ 422: DefaultUnprocessibleSchema
1581
+ },
1582
+ body: ContactContractValidationSchema.addAttachments.request,
1583
+ summary: " attachment information from pre-uploaded files in AWS S3 to contacts."
1506
1584
  }
1507
1585
  },
1508
1586
  {
@@ -1511,61 +1589,537 @@ var contactContract = initContract7().router(
1511
1589
  }
1512
1590
  );
1513
1591
 
1514
- // src/cx-log/index.ts
1592
+ // src/ticket/index.ts
1515
1593
  import { initContract as initContract8 } from "@ts-rest/core";
1594
+ import z30 from "zod";
1595
+
1596
+ // src/ticket/schema.ts
1597
+ import z28 from "zod";
1598
+ var TicketCustomFieldSchema = DefaultEntitySchema.extend({
1599
+ textValue: z28.string().nullable(),
1600
+ booleanValue: z28.boolean().nullable(),
1601
+ numberValue: z28.number().nullable(),
1602
+ dateValue: z28.date().nullable(),
1603
+ attribute: AttributeSchema.omit({ options: true, group: true }),
1604
+ uploads: z28.array(
1605
+ z28.object({
1606
+ id: z28.string().uuid(),
1607
+ createdAt: z28.date(),
1608
+ updatedAt: z28.date(),
1609
+ deletedAt: z28.date().nullable(),
1610
+ customFieldId: z28.string(),
1611
+ upload: UploadSchema
1612
+ })
1613
+ )
1614
+ });
1615
+ var TicketSchema = DefaultEntitySchema.extend({
1616
+ title: z28.string(),
1617
+ description: z28.string().nullable(),
1618
+ type: z28.string(),
1619
+ channel: z28.string(),
1620
+ priority: z28.string(),
1621
+ status: z28.string(),
1622
+ contactId: z28.string().uuid(),
1623
+ creatorId: z28.string().uuid(),
1624
+ assigneeId: z28.string().uuid(),
1625
+ reasonToAssign: z28.string().nullable(),
1626
+ ticketNumber: z28.number().optional(),
1627
+ customFields: z28.array(TicketCustomFieldSchema)
1628
+ });
1629
+ var TicketCountByContactSchema = z28.object({
1630
+ total: z28.coerce.number(),
1631
+ open: z28.coerce.number(),
1632
+ pending: z28.coerce.number(),
1633
+ closed: z28.coerce.number(),
1634
+ solved: z28.coerce.number()
1635
+ }).optional();
1636
+ var TicketParamsSchema = z28.object({
1637
+ page: z28.coerce.number().default(1),
1638
+ pageSize: z28.coerce.number().default(10)
1639
+ }).optional();
1640
+ var CustomFieldQuery = z28.object({
1641
+ attributeId: z28.string(),
1642
+ type: z28.string(),
1643
+ value: z28.union([z28.string(), z28.array(z28.string())])
1644
+ });
1645
+ var GetAllTicketQuerySchema = z28.object({
1646
+ page: z28.number().default(1),
1647
+ pageSize: z28.number().default(10),
1648
+ agent: z28.array(z28.string()),
1649
+ selectedDate: z28.string(),
1650
+ keyword: z28.string(),
1651
+ title: z28.string(),
1652
+ description: z28.string(),
1653
+ status: z28.array(z28.string()),
1654
+ priority: z28.array(z28.string()),
1655
+ channel: z28.array(z28.string()),
1656
+ type: z28.array(z28.string()),
1657
+ ticketType: z28.array(z28.string()),
1658
+ contact: z28.array(z28.string()),
1659
+ tags: z28.array(z28.string()),
1660
+ categories: z28.array(z28.string()),
1661
+ customFields: z28.array(CustomFieldQuery)
1662
+ }).partial();
1663
+
1664
+ // src/ticket/validation.ts
1516
1665
  import z29 from "zod";
1666
+ var BaseSchema2 = z29.object({
1667
+ isRequired: z29.boolean(),
1668
+ attributeId: z29.string()
1669
+ });
1670
+ var SingleValue2 = {
1671
+ value: z29.string()
1672
+ };
1673
+ var CreateTicketValidationSchema = z29.object({
1674
+ title: BaseSchema2.extend(SingleValue2),
1675
+ description: BaseSchema2.extend(SingleValue2),
1676
+ status: BaseSchema2.extend(SingleValue2),
1677
+ type: BaseSchema2.extend(SingleValue2),
1678
+ priority: BaseSchema2.extend(SingleValue2),
1679
+ contact: BaseSchema2.extend(SingleValue2),
1680
+ assignee: BaseSchema2.extend(SingleValue2),
1681
+ channel: BaseSchema2.extend(SingleValue2),
1682
+ tags: BaseSchema2.extend({ value: z29.array(z29.string()) }),
1683
+ categories: BaseSchema2.extend({ value: z29.array(z29.string()) }),
1684
+ customFields: z29.array(
1685
+ BaseSchema2.extend({
1686
+ value: z29.union([z29.string(), z29.array(z29.string())]),
1687
+ type: z29.string(),
1688
+ isDefaultAttribute: z29.boolean()
1689
+ })
1690
+ ),
1691
+ reasonToAssign: z29.object({ value: z29.string() })
1692
+ });
1693
+ var UpdateTicketValidationSchema = CreateTicketValidationSchema.extend(
1694
+ {
1695
+ id: z29.string()
1696
+ }
1697
+ );
1698
+ var TicketAttachmentRecordSchema = z29.object({
1699
+ bucketName: z29.string(),
1700
+ fileKey: z29.string(),
1701
+ fileName: z29.string(),
1702
+ fileSize: z29.coerce.number(),
1703
+ url: z29.string()
1704
+ });
1705
+ var CreateTicketAttachmentRecordsSchema = z29.object({
1706
+ ticketId: z29.string(),
1707
+ attributeId: z29.string(),
1708
+ ticketAttachmentRecords: z29.array(TicketAttachmentRecordSchema)
1709
+ });
1710
+
1711
+ // src/ticket/index.ts
1712
+ var ticketContract = initContract8().router(
1713
+ {
1714
+ createTicket: {
1715
+ method: "POST",
1716
+ path: "",
1717
+ headers: DefaultHeaderSchema,
1718
+ responses: {
1719
+ 201: DefaultSuccessResponseSchema.extend({
1720
+ message: TicketSchema
1721
+ }),
1722
+ 400: z30.object({
1723
+ message: z30.string()
1724
+ }),
1725
+ 409: z30.object({
1726
+ message: z30.string()
1727
+ }),
1728
+ 500: z30.object({
1729
+ message: z30.string()
1730
+ }),
1731
+ 401: DefaultUnauthorizedSchema,
1732
+ 404: DefaultNotFoundSchema,
1733
+ 422: DefaultUnprocessibleSchema
1734
+ },
1735
+ body: CreateTicketValidationSchema,
1736
+ summary: "Create a new ticket"
1737
+ },
1738
+ getAllTickets: {
1739
+ method: "GET",
1740
+ path: "",
1741
+ query: GetAllTicketQuerySchema,
1742
+ headers: DefaultHeaderSchema,
1743
+ responses: {
1744
+ 200: WithPagination(
1745
+ // The response data should contain the user relation.
1746
+ TicketSchema
1747
+ ),
1748
+ 400: z30.object({
1749
+ message: z30.string()
1750
+ }),
1751
+ 401: DefaultUnauthorizedSchema,
1752
+ 500: DefaultErrorResponseSchema
1753
+ },
1754
+ summary: "Get all tickets"
1755
+ },
1756
+ getTicketById: {
1757
+ method: "GET",
1758
+ path: "/:id",
1759
+ pathParams: z30.object({ id: z30.string() }),
1760
+ headers: DefaultHeaderSchema,
1761
+ responses: {
1762
+ 200: TicketSchema,
1763
+ 400: z30.object({
1764
+ message: z30.string()
1765
+ }),
1766
+ 401: DefaultUnauthorizedSchema,
1767
+ 500: DefaultErrorResponseSchema
1768
+ },
1769
+ summary: "Get ticket by id"
1770
+ },
1771
+ getTicketByContactId: {
1772
+ method: "GET",
1773
+ path: "/contact/:id",
1774
+ pathParams: z30.object({ id: z30.string() }),
1775
+ query: TicketParamsSchema,
1776
+ headers: DefaultHeaderSchema,
1777
+ responses: {
1778
+ 200: WithPagination(TicketSchema),
1779
+ 400: z30.object({
1780
+ message: z30.string()
1781
+ }),
1782
+ 401: DefaultUnauthorizedSchema,
1783
+ 500: DefaultErrorResponseSchema
1784
+ },
1785
+ summary: "Get ticket by contact id."
1786
+ },
1787
+ updateTicket: {
1788
+ method: "PATCH",
1789
+ path: "/:id",
1790
+ pathParams: z30.object({ id: z30.string() }),
1791
+ body: UpdateTicketValidationSchema,
1792
+ headers: DefaultHeaderSchema,
1793
+ responses: {
1794
+ 201: DefaultSuccessResponseSchema.extend({
1795
+ message: TicketSchema
1796
+ }),
1797
+ 400: z30.object({
1798
+ message: z30.string()
1799
+ }),
1800
+ 409: z30.object({
1801
+ message: z30.string()
1802
+ }),
1803
+ 500: z30.object({
1804
+ message: z30.string()
1805
+ }),
1806
+ 401: DefaultUnauthorizedSchema,
1807
+ 404: DefaultNotFoundSchema,
1808
+ 422: DefaultUnprocessibleSchema
1809
+ },
1810
+ summary: "Update a contact"
1811
+ },
1812
+ deleteTicket: {
1813
+ method: "DELETE",
1814
+ path: "/:id",
1815
+ pathParams: z30.object({ id: z30.string() }),
1816
+ headers: DefaultHeaderSchema,
1817
+ body: null,
1818
+ responses: {
1819
+ 200: DefaultSuccessResponseSchema.extend({ message: z30.string() }),
1820
+ 500: DefaultErrorResponseSchema
1821
+ },
1822
+ summary: "Delete a extension."
1823
+ },
1824
+ updateDescription: {
1825
+ method: "PATCH",
1826
+ path: "/description/update/:id",
1827
+ pathParams: z30.object({ id: z30.string() }),
1828
+ body: z30.object({ description: z30.string() }),
1829
+ headers: DefaultHeaderSchema,
1830
+ responses: {
1831
+ 201: DefaultSuccessResponseSchema.extend({ message: z30.string() }),
1832
+ 400: z30.object({
1833
+ message: z30.string()
1834
+ }),
1835
+ 409: z30.object({
1836
+ message: z30.string()
1837
+ }),
1838
+ 500: z30.object({
1839
+ message: z30.string()
1840
+ }),
1841
+ 401: DefaultUnauthorizedSchema,
1842
+ 404: DefaultNotFoundSchema,
1843
+ 422: DefaultUnprocessibleSchema
1844
+ },
1845
+ summary: "Update a description from a ticket"
1846
+ },
1847
+ updateTitle: {
1848
+ method: "PATCH",
1849
+ path: "/title/update/:id",
1850
+ pathParams: z30.object({ id: z30.string() }),
1851
+ body: z30.object({ title: z30.string() }),
1852
+ headers: DefaultHeaderSchema,
1853
+ responses: {
1854
+ 200: DefaultSuccessResponseSchema.extend({ message: z30.string() }),
1855
+ 400: z30.object({
1856
+ message: z30.string()
1857
+ }),
1858
+ 409: z30.object({
1859
+ message: z30.string()
1860
+ }),
1861
+ 500: z30.object({
1862
+ message: z30.string()
1863
+ }),
1864
+ 401: DefaultUnauthorizedSchema,
1865
+ 404: DefaultNotFoundSchema,
1866
+ 422: DefaultUnprocessibleSchema
1867
+ },
1868
+ summary: "Update a title from a ticket"
1869
+ },
1870
+ updateType: {
1871
+ method: "PATCH",
1872
+ path: "/type/update/:id",
1873
+ pathParams: z30.object({ id: z30.string() }),
1874
+ body: z30.object({ type: z30.string() }),
1875
+ headers: DefaultHeaderSchema,
1876
+ responses: {
1877
+ 200: DefaultSuccessResponseSchema.extend({ message: z30.string() }),
1878
+ 400: z30.object({
1879
+ message: z30.string()
1880
+ }),
1881
+ 409: z30.object({
1882
+ message: z30.string()
1883
+ }),
1884
+ 500: z30.object({
1885
+ message: z30.string()
1886
+ }),
1887
+ 401: DefaultUnauthorizedSchema,
1888
+ 404: DefaultNotFoundSchema,
1889
+ 422: DefaultUnprocessibleSchema
1890
+ },
1891
+ summary: "Update a type from a ticket"
1892
+ },
1893
+ updateStatus: {
1894
+ method: "PATCH",
1895
+ path: "/status/update/:id",
1896
+ pathParams: z30.object({ id: z30.string() }),
1897
+ body: z30.object({ status: z30.string() }),
1898
+ headers: DefaultHeaderSchema,
1899
+ responses: {
1900
+ 200: DefaultSuccessResponseSchema.extend({ message: z30.string() }),
1901
+ 400: z30.object({
1902
+ message: z30.string()
1903
+ }),
1904
+ 409: z30.object({
1905
+ message: z30.string()
1906
+ }),
1907
+ 500: z30.object({
1908
+ message: z30.string()
1909
+ }),
1910
+ 401: DefaultUnauthorizedSchema,
1911
+ 404: DefaultNotFoundSchema,
1912
+ 422: DefaultUnprocessibleSchema
1913
+ },
1914
+ summary: "Update a status from a ticket"
1915
+ },
1916
+ updatePriority: {
1917
+ method: "PATCH",
1918
+ path: "/priority/update/:id",
1919
+ pathParams: z30.object({ id: z30.string() }),
1920
+ body: z30.object({ priority: z30.string() }),
1921
+ headers: DefaultHeaderSchema,
1922
+ responses: {
1923
+ 200: DefaultSuccessResponseSchema.extend({ message: z30.string() }),
1924
+ 400: z30.object({
1925
+ message: z30.string()
1926
+ }),
1927
+ 409: z30.object({
1928
+ message: z30.string()
1929
+ }),
1930
+ 500: z30.object({
1931
+ message: z30.string()
1932
+ }),
1933
+ 401: DefaultUnauthorizedSchema,
1934
+ 404: DefaultNotFoundSchema,
1935
+ 422: DefaultUnprocessibleSchema
1936
+ },
1937
+ summary: "Update a priority from a ticket"
1938
+ },
1939
+ updateChannel: {
1940
+ method: "PATCH",
1941
+ path: "/channel/update/:id",
1942
+ pathParams: z30.object({ id: z30.string() }),
1943
+ body: z30.object({ channel: z30.string() }),
1944
+ headers: DefaultHeaderSchema,
1945
+ responses: {
1946
+ 200: DefaultSuccessResponseSchema.extend({ message: z30.string() }),
1947
+ 400: z30.object({
1948
+ message: z30.string()
1949
+ }),
1950
+ 409: z30.object({
1951
+ message: z30.string()
1952
+ }),
1953
+ 500: z30.object({
1954
+ message: z30.string()
1955
+ }),
1956
+ 401: DefaultUnauthorizedSchema,
1957
+ 404: DefaultNotFoundSchema,
1958
+ 422: DefaultUnprocessibleSchema
1959
+ },
1960
+ summary: "Update a channel from a ticket"
1961
+ },
1962
+ updateTags: {
1963
+ method: "PATCH",
1964
+ path: "/tags/update/:id",
1965
+ pathParams: z30.object({ id: z30.string() }),
1966
+ body: z30.object({ tags: z30.array(z30.string()) }),
1967
+ headers: DefaultHeaderSchema,
1968
+ responses: {
1969
+ 200: DefaultSuccessResponseSchema.extend({ message: z30.string() }),
1970
+ 400: z30.object({
1971
+ message: z30.string()
1972
+ }),
1973
+ 409: z30.object({
1974
+ message: z30.string()
1975
+ }),
1976
+ 500: z30.object({
1977
+ message: z30.string()
1978
+ }),
1979
+ 401: DefaultUnauthorizedSchema,
1980
+ 404: DefaultNotFoundSchema,
1981
+ 422: DefaultUnprocessibleSchema
1982
+ },
1983
+ summary: "Update a tags from a ticket"
1984
+ },
1985
+ changeAssignee: {
1986
+ method: "PATCH",
1987
+ path: "/assignee/update/:id",
1988
+ pathParams: z30.object({ id: z30.string() }),
1989
+ body: z30.object({ ticketId: z30.string(), assigneeId: z30.string() }),
1990
+ headers: DefaultHeaderSchema,
1991
+ responses: {
1992
+ 200: TicketSchema,
1993
+ 400: z30.object({
1994
+ message: z30.string()
1995
+ }),
1996
+ 409: z30.object({
1997
+ message: z30.string()
1998
+ }),
1999
+ 500: z30.object({
2000
+ message: z30.string()
2001
+ }),
2002
+ 401: DefaultUnauthorizedSchema,
2003
+ 404: DefaultNotFoundSchema,
2004
+ 422: DefaultUnprocessibleSchema
2005
+ },
2006
+ summary: "Change assignee"
2007
+ },
2008
+ getTicketCountByContact: {
2009
+ method: "GET",
2010
+ path: "/ticket_count/contact/:id",
2011
+ pathParams: z30.object({ id: z30.string() }),
2012
+ headers: DefaultHeaderSchema,
2013
+ responses: {
2014
+ 200: TicketCountByContactSchema,
2015
+ 400: z30.object({
2016
+ message: z30.string()
2017
+ }),
2018
+ 401: DefaultUnauthorizedSchema,
2019
+ 500: DefaultErrorResponseSchema
2020
+ },
2021
+ summary: "Get ticket count by contact"
2022
+ },
2023
+ getTicketByContact: {
2024
+ method: "GET",
2025
+ path: "/contact/:id",
2026
+ pathParams: z30.object({ id: z30.string() }),
2027
+ query: z30.object({
2028
+ page: z30.coerce.number().default(1),
2029
+ pageSize: z30.coerce.number().default(10)
2030
+ }).optional(),
2031
+ headers: DefaultHeaderSchema,
2032
+ responses: {
2033
+ 200: WithPagination(TicketSchema),
2034
+ 400: z30.object({
2035
+ message: z30.string()
2036
+ }),
2037
+ 401: DefaultUnauthorizedSchema,
2038
+ 500: DefaultErrorResponseSchema
2039
+ },
2040
+ summary: "Get ticket by contact id"
2041
+ },
2042
+ createTicketAttachmentRecords: {
2043
+ method: "POST",
2044
+ path: "/attachment",
2045
+ headers: DefaultHeaderSchema,
2046
+ body: CreateTicketAttachmentRecordsSchema,
2047
+ responses: {
2048
+ 201: TicketCustomFieldSchema,
2049
+ 400: z30.object({
2050
+ message: z30.string()
2051
+ }),
2052
+ 409: z30.object({
2053
+ message: z30.string()
2054
+ }),
2055
+ 500: z30.object({
2056
+ message: z30.string()
2057
+ }),
2058
+ 401: DefaultUnauthorizedSchema,
2059
+ 404: DefaultNotFoundSchema,
2060
+ 422: DefaultUnprocessibleSchema
2061
+ },
2062
+ summary: "Create a new ticket attachment"
2063
+ }
2064
+ },
2065
+ { pathPrefix: "ticket" }
2066
+ );
2067
+
2068
+ // src/cx-log/index.ts
2069
+ import { initContract as initContract9 } from "@ts-rest/core";
2070
+ import z32 from "zod";
1517
2071
 
1518
2072
  // src/cx-log/validation.ts
1519
- import z28 from "zod";
1520
- var sentimentScoreSchema = z28.union([
1521
- z28.literal("positive"),
1522
- z28.literal("negative")
2073
+ import z31 from "zod";
2074
+ var sentimentScoreSchema = z31.union([
2075
+ z31.literal("positive"),
2076
+ z31.literal("negative")
1523
2077
  ]);
1524
- var CustomFieldQueryParamsSchema = z28.object({
1525
- attributeId: z28.string(),
1526
- value: z28.union([z28.string(), z28.array(z28.string())]),
1527
- type: z28.string().optional()
2078
+ var CustomFieldQueryParamsSchema = z31.object({
2079
+ attributeId: z31.string(),
2080
+ value: z31.union([z31.string(), z31.array(z31.string())]),
2081
+ type: z31.string().optional()
1528
2082
  });
1529
2083
  var GetAllCxLogQueryParamsSchema = DefaultQueryParamsSchema.extend({
1530
- contactId: z28.string().uuid(),
1531
- caseId: z28.string(),
1532
- channelIds: z28.array(z28.string().uuid()),
1533
- queueId: z28.array(z28.string()),
1534
- agentIds: z28.array(z28.string()),
1535
- direction: z28.array(z28.union([z28.literal("inbound"), z28.literal("outbound")])),
1536
- disposition: z28.array(z28.string()),
1537
- sentimentScore: z28.array(sentimentScoreSchema),
1538
- csatScore: z28.string(),
1539
- sla: z28.array(z28.union([z28.literal("meet"), z28.literal("unmeet")])),
1540
- tags: z28.array(z28.string()),
2084
+ contactId: z31.string().uuid(),
2085
+ caseId: z31.string(),
2086
+ channelIds: z31.array(z31.string().uuid()),
2087
+ queueId: z31.array(z31.string()),
2088
+ agentIds: z31.array(z31.string()),
2089
+ direction: z31.array(z31.union([z31.literal("inbound"), z31.literal("outbound")])),
2090
+ disposition: z31.array(z31.string()),
2091
+ sentimentScore: z31.array(sentimentScoreSchema),
2092
+ csatScore: z31.string(),
2093
+ sla: z31.array(z31.union([z31.literal("meet"), z31.literal("unmeet")])),
2094
+ tags: z31.array(z31.string()),
1541
2095
  // General tags
1542
2096
  // Default contact attributes
1543
- name: z28.string(),
1544
- contactLabels: z28.array(z28.string()),
1545
- email: z28.string(),
1546
- channel: z28.array(z28.string()),
1547
- phone: z28.string(),
1548
- notes: z28.string(),
1549
- address: z28.string(),
1550
- company: z28.array(z28.string()),
2097
+ name: z31.string(),
2098
+ contactLabels: z31.array(z31.string()),
2099
+ email: z31.string(),
2100
+ channel: z31.array(z31.string()),
2101
+ phone: z31.string(),
2102
+ notes: z31.string(),
2103
+ address: z31.string(),
2104
+ company: z31.array(z31.string()),
1551
2105
  // Custom fields
1552
- customFields: z28.array(CustomFieldQueryParamsSchema),
2106
+ customFields: z31.array(CustomFieldQueryParamsSchema),
1553
2107
  // Date filter
1554
- selectedDate: z28.string()
2108
+ selectedDate: z31.string()
1555
2109
  }).partial().optional();
1556
2110
 
1557
2111
  // src/cx-log/index.ts
1558
- var cxLogContract = initContract8().router({
2112
+ var cxLogContract = initContract9().router({
1559
2113
  findAll: {
1560
2114
  method: "GET",
1561
2115
  path: "/cx-logs",
1562
2116
  headers: DefaultHeaderSchema,
1563
2117
  responses: {
1564
2118
  200: DefaultSuccessResponseSchema.extend({
1565
- total: z29.number(),
1566
- page: z29.number(),
1567
- pageSize: z29.number(),
1568
- cxLogs: z29.array(CxLogSchema)
2119
+ total: z32.number(),
2120
+ page: z32.number(),
2121
+ pageSize: z32.number(),
2122
+ cxLogs: z32.array(CxLogSchema)
1569
2123
  }),
1570
2124
  401: DefaultUnauthorizedSchema
1571
2125
  },
@@ -1575,22 +2129,22 @@ var cxLogContract = initContract8().router({
1575
2129
  });
1576
2130
 
1577
2131
  // src/extension/index.ts
1578
- import { initContract as initContract9 } from "@ts-rest/core";
1579
- import z31 from "zod";
2132
+ import { initContract as initContract10 } from "@ts-rest/core";
2133
+ import z34 from "zod";
1580
2134
 
1581
2135
  // src/extension/validation.ts
1582
- import { z as z30 } from "zod";
1583
- var CreateExtensionSchema = z30.object({
1584
- userId: z30.string().nullable(),
1585
- sipUserName: z30.string(),
1586
- extensionId: z30.coerce.number().nullable(),
1587
- extensionName: z30.string().nullable(),
1588
- telephonySignature: z30.string().nullable().optional()
2136
+ import { z as z33 } from "zod";
2137
+ var CreateExtensionSchema = z33.object({
2138
+ userId: z33.string().nullable(),
2139
+ sipUserName: z33.string(),
2140
+ extensionId: z33.coerce.number().nullable(),
2141
+ extensionName: z33.string().nullable(),
2142
+ telephonySignature: z33.string().nullable().optional()
1589
2143
  });
1590
2144
  var UpdateExtensionSchema = CreateExtensionSchema;
1591
2145
 
1592
2146
  // src/extension/index.ts
1593
- var extensionContract = initContract9().router(
2147
+ var extensionContract = initContract10().router(
1594
2148
  {
1595
2149
  createExtension: {
1596
2150
  method: "POST",
@@ -1601,8 +2155,8 @@ var extensionContract = initContract9().router(
1601
2155
  201: DefaultSuccessResponseSchema.extend({
1602
2156
  extension: ExtensionSchema
1603
2157
  }),
1604
- 400: z31.object({
1605
- message: z31.string()
2158
+ 400: z34.object({
2159
+ message: z34.string()
1606
2160
  }),
1607
2161
  401: DefaultUnauthorizedSchema,
1608
2162
  500: DefaultErrorResponseSchema
@@ -1612,10 +2166,10 @@ var extensionContract = initContract9().router(
1612
2166
  getExtensions: {
1613
2167
  method: "GET",
1614
2168
  path: "",
1615
- query: z31.object({
1616
- page: z31.coerce.number().default(1),
1617
- pageSize: z31.coerce.number().default(10),
1618
- keyword: z31.string().optional()
2169
+ query: z34.object({
2170
+ page: z34.coerce.number().default(1),
2171
+ pageSize: z34.coerce.number().default(10),
2172
+ keyword: z34.string().optional()
1619
2173
  }).optional(),
1620
2174
  headers: DefaultHeaderSchema,
1621
2175
  responses: {
@@ -1625,8 +2179,8 @@ var extensionContract = initContract9().router(
1625
2179
  user: UserSchema
1626
2180
  })
1627
2181
  ),
1628
- 400: z31.object({
1629
- message: z31.string()
2182
+ 400: z34.object({
2183
+ message: z34.string()
1630
2184
  }),
1631
2185
  401: DefaultUnauthorizedSchema,
1632
2186
  500: DefaultErrorResponseSchema
@@ -1636,12 +2190,12 @@ var extensionContract = initContract9().router(
1636
2190
  getExtensionByUserId: {
1637
2191
  method: "GET",
1638
2192
  path: "/user/:userId",
1639
- pathParams: z31.object({ userId: z31.string() }),
2193
+ pathParams: z34.object({ userId: z34.string() }),
1640
2194
  headers: DefaultHeaderSchema,
1641
2195
  responses: {
1642
2196
  200: ExtensionSchema,
1643
- 400: z31.object({
1644
- message: z31.string()
2197
+ 400: z34.object({
2198
+ message: z34.string()
1645
2199
  }),
1646
2200
  401: DefaultUnauthorizedSchema,
1647
2201
  500: DefaultErrorResponseSchema
@@ -1651,17 +2205,17 @@ var extensionContract = initContract9().router(
1651
2205
  getExtensionByDialpad: {
1652
2206
  method: "GET",
1653
2207
  path: "/dialpad",
1654
- query: z31.object({
1655
- page: z31.coerce.number().default(1),
1656
- pageSize: z31.coerce.number().default(10),
1657
- keyword: z31.string().optional()
2208
+ query: z34.object({
2209
+ page: z34.coerce.number().default(1),
2210
+ pageSize: z34.coerce.number().default(10),
2211
+ keyword: z34.string().optional()
1658
2212
  }).optional(),
1659
2213
  headers: DefaultHeaderSchema,
1660
2214
  responses: {
1661
2215
  200: WithPagination(ExtensionSchema),
1662
2216
  500: DefaultErrorResponseSchema,
1663
- 400: z31.object({
1664
- message: z31.string()
2217
+ 400: z34.object({
2218
+ message: z34.string()
1665
2219
  }),
1666
2220
  401: DefaultUnauthorizedSchema
1667
2221
  },
@@ -1670,7 +2224,7 @@ var extensionContract = initContract9().router(
1670
2224
  updateExtension: {
1671
2225
  method: "PATCH",
1672
2226
  path: "/:id",
1673
- pathParams: z31.object({ id: z31.string() }),
2227
+ pathParams: z34.object({ id: z34.string() }),
1674
2228
  headers: DefaultHeaderSchema,
1675
2229
  body: UpdateExtensionSchema,
1676
2230
  responses: {
@@ -1684,11 +2238,11 @@ var extensionContract = initContract9().router(
1684
2238
  deleteExtension: {
1685
2239
  method: "DELETE",
1686
2240
  path: "/:id",
1687
- pathParams: z31.object({ id: z31.string() }),
2241
+ pathParams: z34.object({ id: z34.string() }),
1688
2242
  headers: DefaultHeaderSchema,
1689
2243
  body: null,
1690
2244
  responses: {
1691
- 200: DefaultSuccessResponseSchema.extend({ message: z31.string() }),
2245
+ 200: DefaultSuccessResponseSchema.extend({ message: z34.string() }),
1692
2246
  500: DefaultErrorResponseSchema
1693
2247
  },
1694
2248
  summary: "Delete a extension."
@@ -1698,33 +2252,33 @@ var extensionContract = initContract9().router(
1698
2252
  );
1699
2253
 
1700
2254
  // src/line/index.ts
1701
- import { initContract as initContract10 } from "@ts-rest/core";
1702
- import z34 from "zod";
2255
+ import { initContract as initContract11 } from "@ts-rest/core";
2256
+ import z37 from "zod";
1703
2257
 
1704
2258
  // src/line/schema.ts
1705
- import z32 from "zod";
1706
- var ConnectLineSchema = z32.object({
1707
- id: z32.string(),
1708
- accessToken: z32.string()
2259
+ import z35 from "zod";
2260
+ var ConnectLineSchema = z35.object({
2261
+ id: z35.string(),
2262
+ accessToken: z35.string()
1709
2263
  });
1710
2264
 
1711
2265
  // src/line/validation.ts
1712
- import z33 from "zod";
1713
- var SendLineStickerSchema = z33.object({
1714
- userId: z33.string().uuid(),
1715
- packageId: z33.string(),
1716
- stickerId: z33.string(),
1717
- accessToken: z33.string()
2266
+ import z36 from "zod";
2267
+ var SendLineStickerSchema = z36.object({
2268
+ userId: z36.string().uuid(),
2269
+ packageId: z36.string(),
2270
+ stickerId: z36.string(),
2271
+ accessToken: z36.string()
1718
2272
  });
1719
2273
 
1720
2274
  // src/line/index.ts
1721
- var lineContract = initContract10().router({
2275
+ var lineContract = initContract11().router({
1722
2276
  sendSticker: {
1723
2277
  method: "POST",
1724
2278
  path: "sticker",
1725
2279
  responses: {
1726
2280
  200: DefaultSuccessResponseSchema.extend({
1727
- data: z34.any()
2281
+ data: z37.any()
1728
2282
  }),
1729
2283
  500: DefaultErrorResponseSchema
1730
2284
  },
@@ -1736,7 +2290,7 @@ var lineContract = initContract10().router({
1736
2290
  path: "connect",
1737
2291
  responses: {
1738
2292
  200: DefaultSuccessResponseSchema.extend({
1739
- data: z34.any()
2293
+ data: z37.any()
1740
2294
  }),
1741
2295
  500: DefaultErrorResponseSchema
1742
2296
  },
@@ -1746,16 +2300,16 @@ var lineContract = initContract10().router({
1746
2300
  });
1747
2301
 
1748
2302
  // src/mail/email-engine-webhooks-events.contract.ts
1749
- import { initContract as initContract11 } from "@ts-rest/core";
1750
- import z35 from "zod";
1751
- var emailEngineWebhooksEventsContract = initContract11().router({
2303
+ import { initContract as initContract12 } from "@ts-rest/core";
2304
+ import z38 from "zod";
2305
+ var emailEngineWebhooksEventsContract = initContract12().router({
1752
2306
  handleWebhooksEvents: {
1753
2307
  method: "POST",
1754
2308
  path: "/email_engine/webhooks",
1755
2309
  // we don't need to respone anything but added responses just for solving type error
1756
2310
  responses: {
1757
2311
  200: DefaultSuccessResponseSchema.extend({
1758
- message: z35.string()
2312
+ message: z38.string()
1759
2313
  })
1760
2314
  },
1761
2315
  body: null,
@@ -1764,189 +2318,189 @@ var emailEngineWebhooksEventsContract = initContract11().router({
1764
2318
  });
1765
2319
 
1766
2320
  // src/mail/mail-contract.ts
1767
- import { initContract as initContract16 } from "@ts-rest/core";
2321
+ import { initContract as initContract17 } from "@ts-rest/core";
1768
2322
 
1769
2323
  // src/mail/room-contract.ts
1770
- import { initContract as initContract12 } from "@ts-rest/core";
1771
- import z39 from "zod";
2324
+ import { initContract as initContract13 } from "@ts-rest/core";
2325
+ import z42 from "zod";
1772
2326
 
1773
2327
  // src/mail/schemas/room.schema.ts
1774
- import z38 from "zod";
2328
+ import z41 from "zod";
1775
2329
 
1776
2330
  // src/mail/schemas/account.schema.ts
1777
- import z36 from "zod";
1778
- var MailServerSchema = z36.object({
1779
- id: z36.string(),
1780
- createdAt: z36.date(),
1781
- updatedAt: z36.date(),
1782
- deletedAt: z36.date().nullable(),
1783
- name: z36.string(),
1784
- smtpHost: z36.string(),
1785
- smtpPort: z36.string(),
1786
- smtpTlsPort: z36.string(),
1787
- useTlsForSmtp: z36.boolean(),
1788
- imapHost: z36.string(),
1789
- imapPort: z36.string(),
1790
- imapTlsPort: z36.string(),
1791
- useTlsForImap: z36.boolean()
1792
- });
1793
- var MailAccountSchema = z36.object({
1794
- id: z36.string(),
1795
- createdAt: z36.date(),
1796
- updatedAt: z36.date(),
1797
- deletedAt: z36.date().nullable(),
1798
- name: z36.string(),
1799
- address: z36.string(),
1800
- accountId: z36.string(),
1801
- mailServerId: z36.string(),
2331
+ import z39 from "zod";
2332
+ var MailServerSchema = z39.object({
2333
+ id: z39.string(),
2334
+ createdAt: z39.date(),
2335
+ updatedAt: z39.date(),
2336
+ deletedAt: z39.date().nullable(),
2337
+ name: z39.string(),
2338
+ smtpHost: z39.string(),
2339
+ smtpPort: z39.string(),
2340
+ smtpTlsPort: z39.string(),
2341
+ useTlsForSmtp: z39.boolean(),
2342
+ imapHost: z39.string(),
2343
+ imapPort: z39.string(),
2344
+ imapTlsPort: z39.string(),
2345
+ useTlsForImap: z39.boolean()
2346
+ });
2347
+ var MailAccountSchema = z39.object({
2348
+ id: z39.string(),
2349
+ createdAt: z39.date(),
2350
+ updatedAt: z39.date(),
2351
+ deletedAt: z39.date().nullable(),
2352
+ name: z39.string(),
2353
+ address: z39.string(),
2354
+ accountId: z39.string(),
2355
+ mailServerId: z39.string(),
1802
2356
  mailServer: MailServerSchema,
1803
- state: z36.union([
1804
- z36.literal("init"),
1805
- z36.literal("syncing"),
1806
- z36.literal("connecting"),
1807
- z36.literal("connected"),
1808
- z36.literal("disconnected"),
1809
- z36.literal("authenticationError"),
1810
- z36.literal("connectError"),
1811
- z36.literal("unset")
2357
+ state: z39.union([
2358
+ z39.literal("init"),
2359
+ z39.literal("syncing"),
2360
+ z39.literal("connecting"),
2361
+ z39.literal("connected"),
2362
+ z39.literal("disconnected"),
2363
+ z39.literal("authenticationError"),
2364
+ z39.literal("connectError"),
2365
+ z39.literal("unset")
1812
2366
  ])
1813
2367
  });
1814
2368
 
1815
2369
  // src/mail/schemas/message.schema.ts
1816
- import z37 from "zod";
1817
- var AttachmentSchema = z37.object({
1818
- id: z37.string(),
1819
- createdAt: z37.date(),
1820
- updatedAt: z37.date(),
1821
- deletedAt: z37.nullable(z37.date()),
1822
- roomId: z37.string(),
1823
- messageId: z37.string(),
1824
- fileName: z37.string(),
1825
- fileType: z37.string(),
1826
- emailEngineAttachmentId: z37.string(),
1827
- uploadId: z37.string(),
1828
- upload: z37.object({
1829
- id: z37.string(),
1830
- createdAt: z37.date(),
1831
- updatedAt: z37.date(),
1832
- deletedAt: z37.nullable(z37.date()),
1833
- bucket_name: z37.string(),
1834
- file_name: z37.string(),
1835
- file_key: z37.string(),
1836
- file_size: z37.number(),
1837
- file_url: z37.string(),
1838
- extension_name: z37.string()
2370
+ import z40 from "zod";
2371
+ var AttachmentSchema = z40.object({
2372
+ id: z40.string(),
2373
+ createdAt: z40.date(),
2374
+ updatedAt: z40.date(),
2375
+ deletedAt: z40.nullable(z40.date()),
2376
+ roomId: z40.string(),
2377
+ messageId: z40.string(),
2378
+ fileName: z40.string(),
2379
+ fileType: z40.string(),
2380
+ emailEngineAttachmentId: z40.string(),
2381
+ uploadId: z40.string(),
2382
+ upload: z40.object({
2383
+ id: z40.string(),
2384
+ createdAt: z40.date(),
2385
+ updatedAt: z40.date(),
2386
+ deletedAt: z40.nullable(z40.date()),
2387
+ bucket_name: z40.string(),
2388
+ file_name: z40.string(),
2389
+ file_key: z40.string(),
2390
+ file_size: z40.number(),
2391
+ file_url: z40.string(),
2392
+ extension_name: z40.string()
1839
2393
  })
1840
2394
  });
1841
- var MessageSchema2 = z37.object({
1842
- id: z37.string(),
1843
- createdAt: z37.date(),
1844
- updatedAt: z37.date(),
1845
- deletedAt: z37.nullable(z37.date()),
1846
- roomId: z37.string(),
1847
- subject: z37.string(),
1848
- textPlain: z37.string(),
1849
- textHtml: z37.string(),
1850
- textId: z37.string(),
1851
- emailEngineEmailId: z37.string(),
1852
- emailEngineMessageId: z37.string(),
1853
- emailEngineReplyTo: z37.nullable(z37.string()),
1854
- direction: z37.string(),
1855
- date: z37.date(),
1856
- action: z37.string(),
1857
- unseen: z37.boolean(),
1858
- seemsLikeNew: z37.boolean(),
1859
- from: z37.array(MailUserSchema),
1860
- to: z37.array(MailUserSchema),
1861
- cc: z37.array(MailUserSchema),
1862
- bcc: z37.array(MailUserSchema),
1863
- attachments: z37.array(AttachmentSchema)
2395
+ var MessageSchema2 = z40.object({
2396
+ id: z40.string(),
2397
+ createdAt: z40.date(),
2398
+ updatedAt: z40.date(),
2399
+ deletedAt: z40.nullable(z40.date()),
2400
+ roomId: z40.string(),
2401
+ subject: z40.string(),
2402
+ textPlain: z40.string(),
2403
+ textHtml: z40.string(),
2404
+ textId: z40.string(),
2405
+ emailEngineEmailId: z40.string(),
2406
+ emailEngineMessageId: z40.string(),
2407
+ emailEngineReplyTo: z40.nullable(z40.string()),
2408
+ direction: z40.string(),
2409
+ date: z40.date(),
2410
+ action: z40.string(),
2411
+ unseen: z40.boolean(),
2412
+ seemsLikeNew: z40.boolean(),
2413
+ from: z40.array(MailUserSchema),
2414
+ to: z40.array(MailUserSchema),
2415
+ cc: z40.array(MailUserSchema),
2416
+ bcc: z40.array(MailUserSchema),
2417
+ attachments: z40.array(AttachmentSchema)
1864
2418
  });
1865
2419
 
1866
2420
  // src/mail/schemas/room.schema.ts
1867
- var MailUserSchema = z38.object({
1868
- id: z38.string(),
1869
- createdAt: z38.date(),
1870
- updatedAt: z38.date(),
1871
- deletedAt: z38.date().nullable(),
1872
- name: z38.string(),
1873
- address: z38.string()
1874
- });
1875
- var TagSchema2 = z38.object({
1876
- color: z38.string(),
1877
- id: z38.string(),
1878
- createdAt: z38.date(),
1879
- updatedAt: z38.date(),
1880
- deletedAt: z38.date().nullable(),
1881
- name: z38.string()
1882
- });
1883
- var UserModel = z38.object({
1884
- id: z38.string().uuid(),
1885
- createdAt: z38.date(),
1886
- updatedAt: z38.date(),
1887
- deletedAt: z38.date().nullable(),
1888
- name: z38.string(),
1889
- email: z38.string(),
1890
- address: z38.string().nullable(),
1891
- phone: z38.string().nullable(),
1892
- notification_count: z38.number().nullable()
1893
- });
1894
- var ActivityLogModel = z38.object({
1895
- id: z38.string(),
1896
- createdAt: z38.string(),
1897
- updatedAt: z38.string(),
1898
- deletedAt: z38.nullable(z38.string()),
1899
- description: z38.string(),
1900
- actorId: z38.string(),
1901
- roomId: z38.string(),
2421
+ var MailUserSchema = z41.object({
2422
+ id: z41.string(),
2423
+ createdAt: z41.date(),
2424
+ updatedAt: z41.date(),
2425
+ deletedAt: z41.date().nullable(),
2426
+ name: z41.string(),
2427
+ address: z41.string()
2428
+ });
2429
+ var TagSchema2 = z41.object({
2430
+ color: z41.string(),
2431
+ id: z41.string(),
2432
+ createdAt: z41.date(),
2433
+ updatedAt: z41.date(),
2434
+ deletedAt: z41.date().nullable(),
2435
+ name: z41.string()
2436
+ });
2437
+ var UserModel = z41.object({
2438
+ id: z41.string().uuid(),
2439
+ createdAt: z41.date(),
2440
+ updatedAt: z41.date(),
2441
+ deletedAt: z41.date().nullable(),
2442
+ name: z41.string(),
2443
+ email: z41.string(),
2444
+ address: z41.string().nullable(),
2445
+ phone: z41.string().nullable(),
2446
+ notification_count: z41.number().nullable()
2447
+ });
2448
+ var ActivityLogModel = z41.object({
2449
+ id: z41.string(),
2450
+ createdAt: z41.string(),
2451
+ updatedAt: z41.string(),
2452
+ deletedAt: z41.nullable(z41.string()),
2453
+ description: z41.string(),
2454
+ actorId: z41.string(),
2455
+ roomId: z41.string(),
1902
2456
  actor: UserModel
1903
2457
  });
1904
- var MessagesAndLogs = z38.array(z38.union([MessageSchema2, ActivityLogModel]));
1905
- var MailRoomSchema = z38.object({
1906
- id: z38.string(),
1907
- createdAt: z38.date(),
1908
- updatedAt: z38.date(),
1909
- deletedAt: z38.date().nullable(),
1910
- subject: z38.string(),
1911
- resolved: z38.boolean(),
1912
- assigneeId: z38.string().nullable(),
1913
- note: z38.string(),
1914
- mailId: z38.string(),
1915
- direction: z38.string(),
1916
- lastMessageId: z38.string(),
1917
- firstMessageId: z38.string(),
1918
- from: z38.array(MailUserSchema),
1919
- to: z38.array(MailUserSchema),
1920
- cc: z38.array(MailUserSchema),
1921
- bcc: z38.array(MailUserSchema),
2458
+ var MessagesAndLogs = z41.array(z41.union([MessageSchema2, ActivityLogModel]));
2459
+ var MailRoomSchema = z41.object({
2460
+ id: z41.string(),
2461
+ createdAt: z41.date(),
2462
+ updatedAt: z41.date(),
2463
+ deletedAt: z41.date().nullable(),
2464
+ subject: z41.string(),
2465
+ resolved: z41.boolean(),
2466
+ assigneeId: z41.string().nullable(),
2467
+ note: z41.string(),
2468
+ mailId: z41.string(),
2469
+ direction: z41.string(),
2470
+ lastMessageId: z41.string(),
2471
+ firstMessageId: z41.string(),
2472
+ from: z41.array(MailUserSchema),
2473
+ to: z41.array(MailUserSchema),
2474
+ cc: z41.array(MailUserSchema),
2475
+ bcc: z41.array(MailUserSchema),
1922
2476
  firstMessage: MessageSchema2,
1923
2477
  lastMessage: MessageSchema2,
1924
- tags: z38.array(TagSchema2),
2478
+ tags: z41.array(TagSchema2),
1925
2479
  assignee: UserModel,
1926
- messages: z38.array(MessageSchema2),
2480
+ messages: z41.array(MessageSchema2),
1927
2481
  messagesAndLogs: MessagesAndLogs,
1928
2482
  mail: MailAccountSchema,
1929
- unReadMessageCount: z38.number()
1930
- });
1931
- var AttachmentSchema2 = z38.object({
1932
- fileName: z38.string(),
1933
- fileType: z38.string(),
1934
- emailEngineAttachmentId: z38.string(),
1935
- uploadId: z38.string(),
1936
- messageId: z38.string(),
1937
- roomId: z38.string(),
2483
+ unReadMessageCount: z41.number()
2484
+ });
2485
+ var AttachmentSchema2 = z41.object({
2486
+ fileName: z41.string(),
2487
+ fileType: z41.string(),
2488
+ emailEngineAttachmentId: z41.string(),
2489
+ uploadId: z41.string(),
2490
+ messageId: z41.string(),
2491
+ roomId: z41.string(),
1938
2492
  upload: UploadSchema
1939
2493
  });
1940
2494
 
1941
2495
  // src/mail/room-contract.ts
1942
- var roomContract = initContract12().router(
2496
+ var roomContract = initContract13().router(
1943
2497
  {
1944
2498
  create: {
1945
2499
  method: "POST",
1946
2500
  path: "/",
1947
2501
  responses: {
1948
2502
  200: DefaultSuccessResponseSchema.extend({
1949
- message: z39.string()
2503
+ message: z42.string()
1950
2504
  }),
1951
2505
  ...DefaultResponses
1952
2506
  },
@@ -1956,19 +2510,19 @@ var roomContract = initContract12().router(
1956
2510
  getAll: {
1957
2511
  method: "GET",
1958
2512
  path: "",
1959
- query: z39.object({
1960
- page: z39.coerce.number().default(1),
1961
- pageSize: z39.coerce.number().default(10),
1962
- keyword: z39.string().optional(),
1963
- assigneeId: z39.string().uuid().optional().nullable(),
1964
- resolved: z39.boolean().or(z39.string().transform((value) => value.toLowerCase() === "true")).optional().nullable()
2513
+ query: z42.object({
2514
+ page: z42.coerce.number().default(1),
2515
+ pageSize: z42.coerce.number().default(10),
2516
+ keyword: z42.string().optional(),
2517
+ assigneeId: z42.string().uuid().optional().nullable(),
2518
+ resolved: z42.boolean().or(z42.string().transform((value) => value.toLowerCase() === "true")).optional().nullable()
1965
2519
  }),
1966
2520
  responses: {
1967
2521
  200: DefaultSuccessResponseSchema.extend({
1968
- data: z39.array(MailRoomSchema),
1969
- total: z39.number(),
1970
- page: z39.number(),
1971
- pageSize: z39.number()
2522
+ data: z42.array(MailRoomSchema),
2523
+ total: z42.number(),
2524
+ page: z42.number(),
2525
+ pageSize: z42.number()
1972
2526
  }),
1973
2527
  ...DefaultResponses
1974
2528
  },
@@ -1977,8 +2531,8 @@ var roomContract = initContract12().router(
1977
2531
  getById: {
1978
2532
  method: "GET",
1979
2533
  path: "/:id",
1980
- pathParams: z39.object({
1981
- id: z39.string().uuid()
2534
+ pathParams: z42.object({
2535
+ id: z42.string().uuid()
1982
2536
  }),
1983
2537
  responses: {
1984
2538
  200: DefaultSuccessResponseSchema.extend({
@@ -1991,12 +2545,12 @@ var roomContract = initContract12().router(
1991
2545
  getAttachments: {
1992
2546
  method: "GET",
1993
2547
  path: "/:id/attachments",
1994
- pathParams: z39.object({
1995
- id: z39.string().uuid()
2548
+ pathParams: z42.object({
2549
+ id: z42.string().uuid()
1996
2550
  }),
1997
2551
  responses: {
1998
2552
  200: DefaultSuccessResponseSchema.extend({
1999
- data: z39.array(AttachmentSchema2)
2553
+ data: z42.array(AttachmentSchema2)
2000
2554
  }),
2001
2555
  ...DefaultResponses
2002
2556
  },
@@ -2005,12 +2559,12 @@ var roomContract = initContract12().router(
2005
2559
  getParticipants: {
2006
2560
  method: "GET",
2007
2561
  path: "/:id/participants",
2008
- pathParams: z39.object({
2009
- id: z39.string().uuid()
2562
+ pathParams: z42.object({
2563
+ id: z42.string().uuid()
2010
2564
  }),
2011
2565
  responses: {
2012
2566
  200: DefaultSuccessResponseSchema.extend({
2013
- data: z39.array(MailUserSchema)
2567
+ data: z42.array(MailUserSchema)
2014
2568
  }),
2015
2569
  ...DefaultResponses
2016
2570
  },
@@ -2019,8 +2573,8 @@ var roomContract = initContract12().router(
2019
2573
  update: {
2020
2574
  method: "PATCH",
2021
2575
  path: "/:id",
2022
- pathParams: z39.object({
2023
- id: z39.string()
2576
+ pathParams: z42.object({
2577
+ id: z42.string()
2024
2578
  }),
2025
2579
  responses: {
2026
2580
  200: DefaultSuccessResponseSchema.extend({
@@ -2028,15 +2582,15 @@ var roomContract = initContract12().router(
2028
2582
  }),
2029
2583
  ...DefaultResponses
2030
2584
  },
2031
- body: z39.object({
2032
- resolved: z39.boolean().or(
2033
- z39.union([z39.literal("true"), z39.literal("false")]).transform((value) => value.toLowerCase() === "true")
2585
+ body: z42.object({
2586
+ resolved: z42.boolean().or(
2587
+ z42.union([z42.literal("true"), z42.literal("false")]).transform((value) => value.toLowerCase() === "true")
2034
2588
  ).optional().nullable(),
2035
- assigneeId: z39.string().uuid().optional().nullable(),
2036
- note: z39.string().optional(),
2037
- tags: z39.array(z39.string().uuid()).optional(),
2038
- handover: z39.boolean().or(
2039
- z39.union([z39.literal("true"), z39.literal("false")]).transform((value) => value.toLowerCase() === "true")
2589
+ assigneeId: z42.string().uuid().optional().nullable(),
2590
+ note: z42.string().optional(),
2591
+ tags: z42.array(z42.string().uuid()).optional(),
2592
+ handover: z42.boolean().or(
2593
+ z42.union([z42.literal("true"), z42.literal("false")]).transform((value) => value.toLowerCase() === "true")
2040
2594
  ).optional().nullable()
2041
2595
  }),
2042
2596
  summary: "Update a mail room by id"
@@ -2044,12 +2598,12 @@ var roomContract = initContract12().router(
2044
2598
  markAsRead: {
2045
2599
  method: "GET",
2046
2600
  path: "/:id",
2047
- pathParams: z39.object({
2048
- id: z39.string().uuid()
2601
+ pathParams: z42.object({
2602
+ id: z42.string().uuid()
2049
2603
  }),
2050
2604
  responses: {
2051
2605
  200: DefaultSuccessResponseSchema.extend({
2052
- message: z39.string()
2606
+ message: z42.string()
2053
2607
  }),
2054
2608
  ...DefaultResponses
2055
2609
  },
@@ -2062,55 +2616,55 @@ var roomContract = initContract12().router(
2062
2616
  );
2063
2617
 
2064
2618
  // src/mail/account-contract.ts
2065
- import { initContract as initContract13 } from "@ts-rest/core";
2066
- import z41 from "zod";
2619
+ import { initContract as initContract14 } from "@ts-rest/core";
2620
+ import z44 from "zod";
2067
2621
 
2068
2622
  // src/mail/schemas/account-validation.schema.ts
2069
- import z40 from "zod";
2623
+ import z43 from "zod";
2070
2624
  var AccountContractsValidationSchemas = {
2071
2625
  create: {
2072
- input: z40.object({
2073
- address: z40.string().email("Email address must be valid email."),
2074
- name: z40.string().min(1, "Account name cannot be empty."),
2075
- password: z40.string().min(1, "Password cannot be empty."),
2076
- mailServerId: z40.string().uuid("Invalid mail_server_id")
2626
+ input: z43.object({
2627
+ address: z43.string().email("Email address must be valid email."),
2628
+ name: z43.string().min(1, "Account name cannot be empty."),
2629
+ password: z43.string().min(1, "Password cannot be empty."),
2630
+ mailServerId: z43.string().uuid("Invalid mail_server_id")
2077
2631
  })
2078
2632
  },
2079
2633
  getById: {
2080
- input: z40.object({
2081
- id: z40.string().uuid()
2634
+ input: z43.object({
2635
+ id: z43.string().uuid()
2082
2636
  }),
2083
2637
  output: MailAccountSchema
2084
2638
  },
2085
2639
  getAll: {
2086
- output: z40.array(MailAccountSchema)
2640
+ output: z43.array(MailAccountSchema)
2087
2641
  },
2088
2642
  update: {
2089
2643
  input: MailAccountSchema,
2090
2644
  output: MailAccountSchema
2091
2645
  },
2092
2646
  disconnect: {
2093
- input: z40.object({
2094
- id: z40.string().uuid()
2647
+ input: z43.object({
2648
+ id: z43.string().uuid()
2095
2649
  }),
2096
2650
  output: MailAccountSchema
2097
2651
  },
2098
2652
  reconnect: {
2099
- input: z40.object({
2100
- id: z40.string()
2653
+ input: z43.object({
2654
+ id: z43.string()
2101
2655
  }),
2102
2656
  output: MailAccountSchema
2103
2657
  },
2104
2658
  delete: {
2105
- input: z40.object({
2106
- id: z40.string()
2659
+ input: z43.object({
2660
+ id: z43.string()
2107
2661
  }),
2108
2662
  output: MailAccountSchema
2109
2663
  }
2110
2664
  };
2111
2665
 
2112
2666
  // src/mail/account-contract.ts
2113
- var accountContract = initContract13().router(
2667
+ var accountContract = initContract14().router(
2114
2668
  {
2115
2669
  //#region ........register account
2116
2670
  create: {
@@ -2119,16 +2673,16 @@ var accountContract = initContract13().router(
2119
2673
  responses: {
2120
2674
  201: DefaultSuccessResponseSchema.extend({
2121
2675
  // data: AccountContractsValidationSchemas.create.output,
2122
- message: z41.string()
2676
+ message: z44.string()
2123
2677
  }),
2124
- 400: z41.object({
2125
- message: z41.string()
2678
+ 400: z44.object({
2679
+ message: z44.string()
2126
2680
  }),
2127
- 409: z41.object({
2128
- message: z41.string()
2681
+ 409: z44.object({
2682
+ message: z44.string()
2129
2683
  }),
2130
- 500: z41.object({
2131
- message: z41.string()
2684
+ 500: z44.object({
2685
+ message: z44.string()
2132
2686
  }),
2133
2687
  ...DefaultResponses
2134
2688
  },
@@ -2157,7 +2711,7 @@ var accountContract = initContract13().router(
2157
2711
  path: "",
2158
2712
  responses: {
2159
2713
  200: DefaultSuccessResponseSchema.extend({
2160
- data: z41.any()
2714
+ data: z44.any()
2161
2715
  // data: AccountContractsValidationSchemas.getAll.output,
2162
2716
  }),
2163
2717
  ...DefaultResponses
@@ -2169,8 +2723,8 @@ var accountContract = initContract13().router(
2169
2723
  update: {
2170
2724
  method: "PATCH",
2171
2725
  path: "/:id",
2172
- pathParams: z41.object({
2173
- id: z41.string().uuid()
2726
+ pathParams: z44.object({
2727
+ id: z44.string().uuid()
2174
2728
  }),
2175
2729
  responses: {
2176
2730
  201: DefaultSuccessResponseSchema.extend({
@@ -2219,7 +2773,7 @@ var accountContract = initContract13().router(
2219
2773
  pathParams: AccountContractsValidationSchemas.delete.input,
2220
2774
  responses: {
2221
2775
  200: DefaultSuccessResponseSchema.extend({
2222
- message: z41.string()
2776
+ message: z44.string()
2223
2777
  }),
2224
2778
  ...DefaultResponses
2225
2779
  },
@@ -2235,16 +2789,16 @@ var accountContract = initContract13().router(
2235
2789
  );
2236
2790
 
2237
2791
  // src/mail/mail-server-contract.ts
2238
- import { initContract as initContract14 } from "@ts-rest/core";
2239
- import z42 from "zod";
2240
- var serverContract = initContract14().router(
2792
+ import { initContract as initContract15 } from "@ts-rest/core";
2793
+ import z45 from "zod";
2794
+ var serverContract = initContract15().router(
2241
2795
  {
2242
2796
  create: {
2243
2797
  method: "POST",
2244
2798
  path: "/",
2245
2799
  responses: {
2246
2800
  200: DefaultSuccessResponseSchema.extend({
2247
- message: z42.string()
2801
+ message: z45.string()
2248
2802
  }),
2249
2803
  ...DefaultResponses
2250
2804
  },
@@ -2254,12 +2808,12 @@ var serverContract = initContract14().router(
2254
2808
  get: {
2255
2809
  method: "GET",
2256
2810
  path: "/:id",
2257
- pathParams: z42.object({
2258
- id: z42.string()
2811
+ pathParams: z45.object({
2812
+ id: z45.string()
2259
2813
  }),
2260
2814
  responses: {
2261
2815
  200: DefaultSuccessResponseSchema.extend({
2262
- message: z42.string()
2816
+ message: z45.string()
2263
2817
  }),
2264
2818
  ...DefaultResponses
2265
2819
  },
@@ -2268,12 +2822,12 @@ var serverContract = initContract14().router(
2268
2822
  update: {
2269
2823
  method: "PATCH",
2270
2824
  path: "/:id",
2271
- pathParams: z42.object({
2272
- id: z42.string()
2825
+ pathParams: z45.object({
2826
+ id: z45.string()
2273
2827
  }),
2274
2828
  responses: {
2275
2829
  200: DefaultSuccessResponseSchema.extend({
2276
- message: z42.string()
2830
+ message: z45.string()
2277
2831
  }),
2278
2832
  ...DefaultResponses
2279
2833
  },
@@ -2283,12 +2837,12 @@ var serverContract = initContract14().router(
2283
2837
  delete: {
2284
2838
  method: "PATCH",
2285
2839
  path: "/:id",
2286
- pathParams: z42.object({
2287
- id: z42.string()
2840
+ pathParams: z45.object({
2841
+ id: z45.string()
2288
2842
  }),
2289
2843
  responses: {
2290
2844
  200: DefaultSuccessResponseSchema.extend({
2291
- message: z42.string()
2845
+ message: z45.string()
2292
2846
  }),
2293
2847
  ...DefaultResponses
2294
2848
  },
@@ -2302,51 +2856,51 @@ var serverContract = initContract14().router(
2302
2856
  );
2303
2857
 
2304
2858
  // src/mail/message-contract.ts
2305
- import { initContract as initContract15 } from "@ts-rest/core";
2306
- import z44 from "zod";
2859
+ import { initContract as initContract16 } from "@ts-rest/core";
2860
+ import z47 from "zod";
2307
2861
 
2308
2862
  // src/mail/schemas/message-validation.schema.ts
2309
- import z43 from "zod";
2310
- var MailParticipant = z43.object({
2311
- name: z43.string().optional(),
2312
- address: z43.string().email()
2863
+ import z46 from "zod";
2864
+ var MailParticipant = z46.object({
2865
+ name: z46.string().optional(),
2866
+ address: z46.string().email()
2313
2867
  });
2314
2868
  var MessageContractsValidationsSchema = {
2315
2869
  submit: {
2316
- input: z43.object({
2317
- subject: z43.string(),
2318
- text: z43.string(),
2319
- html: z43.string(),
2870
+ input: z46.object({
2871
+ subject: z46.string(),
2872
+ text: z46.string(),
2873
+ html: z46.string(),
2320
2874
  from: MailParticipant,
2321
- to: z43.array(MailParticipant),
2322
- cc: z43.array(MailParticipant).optional(),
2323
- bcc: z43.array(MailParticipant).optional(),
2324
- reference: z43.object({
2325
- messageId: z43.string(),
2326
- action: z43.union([z43.literal("reply"), z43.literal("forward")])
2875
+ to: z46.array(MailParticipant),
2876
+ cc: z46.array(MailParticipant).optional(),
2877
+ bcc: z46.array(MailParticipant).optional(),
2878
+ reference: z46.object({
2879
+ messageId: z46.string(),
2880
+ action: z46.union([z46.literal("reply"), z46.literal("forward")])
2327
2881
  }).optional(),
2328
- attachments: z43.array(
2329
- z43.object({
2330
- fileType: z43.string(),
2331
- fileName: z43.string(),
2332
- fileKey: z43.string(),
2333
- fileSize: z43.number(),
2334
- bucketName: z43.string(),
2335
- presignedUrl: z43.string()
2882
+ attachments: z46.array(
2883
+ z46.object({
2884
+ fileType: z46.string(),
2885
+ fileName: z46.string(),
2886
+ fileKey: z46.string(),
2887
+ fileSize: z46.number(),
2888
+ bucketName: z46.string(),
2889
+ presignedUrl: z46.string()
2336
2890
  })
2337
2891
  ).optional()
2338
2892
  }),
2339
- output: z43.object({
2340
- response: z43.string(),
2341
- messageId: z43.string(),
2342
- sendAt: z43.string(),
2343
- queueId: z43.string()
2893
+ output: z46.object({
2894
+ response: z46.string(),
2895
+ messageId: z46.string(),
2896
+ sendAt: z46.string(),
2897
+ queueId: z46.string()
2344
2898
  })
2345
2899
  }
2346
2900
  };
2347
2901
 
2348
2902
  // src/mail/message-contract.ts
2349
- var messageContract = initContract15().router(
2903
+ var messageContract = initContract16().router(
2350
2904
  {
2351
2905
  submit: {
2352
2906
  method: "POST",
@@ -2365,8 +2919,8 @@ var messageContract = initContract15().router(
2365
2919
  getById: {
2366
2920
  method: "GET",
2367
2921
  path: "/:id",
2368
- pathParams: z44.object({
2369
- id: z44.string()
2922
+ pathParams: z47.object({
2923
+ id: z47.string()
2370
2924
  }),
2371
2925
  responses: {
2372
2926
  200: DefaultSuccessResponseSchema.extend({
@@ -2384,7 +2938,7 @@ var messageContract = initContract15().router(
2384
2938
  );
2385
2939
 
2386
2940
  // src/mail/mail-contract.ts
2387
- var mailContract = initContract16().router({
2941
+ var mailContract = initContract17().router({
2388
2942
  room: roomContract,
2389
2943
  message: messageContract,
2390
2944
  account: accountContract,
@@ -2392,8 +2946,8 @@ var mailContract = initContract16().router({
2392
2946
  });
2393
2947
 
2394
2948
  // src/messenger/index.ts
2395
- import { initContract as initContract17 } from "@ts-rest/core";
2396
- var messengerContract = initContract17().router({
2949
+ import { initContract as initContract18 } from "@ts-rest/core";
2950
+ var messengerContract = initContract18().router({
2397
2951
  sendMessage: {
2398
2952
  method: "POST",
2399
2953
  path: "/message",
@@ -2408,18 +2962,18 @@ var messengerContract = initContract17().router({
2408
2962
  });
2409
2963
 
2410
2964
  // src/permission/index.ts
2411
- import { initContract as initContract18 } from "@ts-rest/core";
2412
- import z45 from "zod";
2413
- var permissionContract = initContract18().router(
2965
+ import { initContract as initContract19 } from "@ts-rest/core";
2966
+ import z48 from "zod";
2967
+ var permissionContract = initContract19().router(
2414
2968
  {
2415
2969
  getPermissions: {
2416
2970
  method: "GET",
2417
2971
  path: "",
2418
2972
  headers: DefaultHeaderSchema,
2419
2973
  responses: {
2420
- 200: z45.object({ permissions: PermissionSchema.array() }),
2421
- 400: z45.object({
2422
- message: z45.string()
2974
+ 200: z48.object({ permissions: PermissionSchema.array() }),
2975
+ 400: z48.object({
2976
+ message: z48.string()
2423
2977
  }),
2424
2978
  401: DefaultUnauthorizedSchema,
2425
2979
  500: DefaultErrorResponseSchema
@@ -2431,21 +2985,21 @@ var permissionContract = initContract18().router(
2431
2985
  );
2432
2986
 
2433
2987
  // src/role/index.ts
2434
- import { initContract as initContract19 } from "@ts-rest/core";
2435
- import z47 from "zod";
2988
+ import { initContract as initContract20 } from "@ts-rest/core";
2989
+ import z50 from "zod";
2436
2990
 
2437
2991
  // src/role/validation.ts
2438
- import { z as z46 } from "zod";
2439
- var CreateRoleSchema = z46.object({
2440
- systemName: z46.string(),
2441
- displayName: z46.string(),
2442
- description: z46.string().nullable(),
2443
- permissions: z46.array(z46.string())
2992
+ import { z as z49 } from "zod";
2993
+ var CreateRoleSchema = z49.object({
2994
+ systemName: z49.string(),
2995
+ displayName: z49.string(),
2996
+ description: z49.string().nullable(),
2997
+ permissions: z49.array(z49.string())
2444
2998
  });
2445
2999
  var UpdateRoleSchema = CreateRoleSchema;
2446
3000
 
2447
3001
  // src/role/index.ts
2448
- var roleContract = initContract19().router(
3002
+ var roleContract = initContract20().router(
2449
3003
  {
2450
3004
  createRole: {
2451
3005
  method: "POST",
@@ -2456,8 +3010,8 @@ var roleContract = initContract19().router(
2456
3010
  201: DefaultSuccessResponseSchema.extend({
2457
3011
  role: RoleSchema
2458
3012
  }),
2459
- 400: z47.object({
2460
- message: z47.string()
3013
+ 400: z50.object({
3014
+ message: z50.string()
2461
3015
  }),
2462
3016
  401: DefaultUnauthorizedSchema,
2463
3017
  500: DefaultErrorResponseSchema
@@ -2467,15 +3021,15 @@ var roleContract = initContract19().router(
2467
3021
  getRoles: {
2468
3022
  method: "GET",
2469
3023
  path: "",
2470
- query: z47.object({
2471
- page: z47.coerce.number().default(1),
2472
- pageSize: z47.coerce.number().default(10)
3024
+ query: z50.object({
3025
+ page: z50.coerce.number().default(1),
3026
+ pageSize: z50.coerce.number().default(10)
2473
3027
  }).optional(),
2474
3028
  headers: DefaultHeaderSchema,
2475
3029
  responses: {
2476
3030
  200: WithPagination(RoleSchema),
2477
- 400: z47.object({
2478
- message: z47.string()
3031
+ 400: z50.object({
3032
+ message: z50.string()
2479
3033
  }),
2480
3034
  401: DefaultUnauthorizedSchema,
2481
3035
  500: DefaultErrorResponseSchema
@@ -2485,15 +3039,15 @@ var roleContract = initContract19().router(
2485
3039
  updateRole: {
2486
3040
  method: "PATCH",
2487
3041
  path: "/:id",
2488
- pathParams: z47.object({ id: z47.string() }),
3042
+ pathParams: z50.object({ id: z50.string() }),
2489
3043
  headers: DefaultHeaderSchema,
2490
3044
  body: UpdateRoleSchema,
2491
3045
  responses: {
2492
3046
  201: DefaultSuccessResponseSchema.extend({
2493
3047
  role: RoleSchema
2494
3048
  }),
2495
- 400: z47.object({
2496
- message: z47.string()
3049
+ 400: z50.object({
3050
+ message: z50.string()
2497
3051
  }),
2498
3052
  401: DefaultUnauthorizedSchema,
2499
3053
  500: DefaultErrorResponseSchema
@@ -2503,11 +3057,11 @@ var roleContract = initContract19().router(
2503
3057
  deleteRole: {
2504
3058
  method: "DELETE",
2505
3059
  path: "/:id",
2506
- pathParams: z47.object({ id: z47.string() }),
3060
+ pathParams: z50.object({ id: z50.string() }),
2507
3061
  headers: DefaultHeaderSchema,
2508
3062
  body: null,
2509
3063
  responses: {
2510
- 200: DefaultSuccessResponseSchema.extend({ message: z47.string() }),
3064
+ 200: DefaultSuccessResponseSchema.extend({ message: z50.string() }),
2511
3065
  500: DefaultErrorResponseSchema
2512
3066
  },
2513
3067
  summary: "Delete a role."
@@ -2517,23 +3071,23 @@ var roleContract = initContract19().router(
2517
3071
  );
2518
3072
 
2519
3073
  // src/tag/index.ts
2520
- import { initContract as initContract20 } from "@ts-rest/core";
2521
- import z49 from "zod";
3074
+ import { initContract as initContract21 } from "@ts-rest/core";
3075
+ import z52 from "zod";
2522
3076
 
2523
3077
  // src/tag/validation.ts
2524
- import { z as z48 } from "zod";
2525
- var CreateTagSchema = z48.object({
2526
- name: z48.string(),
3078
+ import { z as z51 } from "zod";
3079
+ var CreateTagSchema = z51.object({
3080
+ name: z51.string(),
2527
3081
  group: TagGroupSchema
2528
3082
  });
2529
- var GetTagsSchema = z48.object({
3083
+ var GetTagsSchema = z51.object({
2530
3084
  group: TagGroupSchema.default("general"),
2531
- keyword: z48.string()
3085
+ keyword: z51.string()
2532
3086
  }).partial().optional();
2533
- var UpdateTagSchema = z48.object({ name: z48.string() });
3087
+ var UpdateTagSchema = z51.object({ name: z51.string() });
2534
3088
 
2535
3089
  // src/tag/index.ts
2536
- var tagContract = initContract20().router(
3090
+ var tagContract = initContract21().router(
2537
3091
  {
2538
3092
  createTag: {
2539
3093
  method: "POST",
@@ -2553,7 +3107,7 @@ var tagContract = initContract20().router(
2553
3107
  query: GetTagsSchema,
2554
3108
  responses: {
2555
3109
  200: DefaultSuccessResponseSchema.extend({
2556
- tags: z49.array(TagSchema)
3110
+ tags: z52.array(TagSchema)
2557
3111
  }),
2558
3112
  500: DefaultErrorResponseSchema
2559
3113
  },
@@ -2562,7 +3116,7 @@ var tagContract = initContract20().router(
2562
3116
  updateTag: {
2563
3117
  method: "PATCH",
2564
3118
  path: "/:id",
2565
- pathParams: z49.object({ id: z49.string() }),
3119
+ pathParams: z52.object({ id: z52.string() }),
2566
3120
  body: UpdateTagSchema,
2567
3121
  responses: {
2568
3122
  200: DefaultSuccessResponseSchema.extend({
@@ -2575,11 +3129,11 @@ var tagContract = initContract20().router(
2575
3129
  deleteTag: {
2576
3130
  method: "DELETE",
2577
3131
  path: "/:id",
2578
- pathParams: z49.object({ id: z49.string() }),
2579
- body: z49.any().optional(),
3132
+ pathParams: z52.object({ id: z52.string() }),
3133
+ body: z52.any().optional(),
2580
3134
  // We don't need the body.
2581
3135
  responses: {
2582
- 200: DefaultSuccessResponseSchema.extend({ message: z49.string() }),
3136
+ 200: DefaultSuccessResponseSchema.extend({ message: z52.string() }),
2583
3137
  500: DefaultErrorResponseSchema
2584
3138
  },
2585
3139
  headers: DefaultHeaderSchema
@@ -2591,41 +3145,41 @@ var tagContract = initContract20().router(
2591
3145
  );
2592
3146
 
2593
3147
  // src/telephony-agent-presence-status/index.ts
2594
- import { initContract as initContract21 } from "@ts-rest/core";
2595
- import z52 from "zod";
3148
+ import { initContract as initContract22 } from "@ts-rest/core";
3149
+ import z55 from "zod";
2596
3150
 
2597
3151
  // src/telephony-agent-presence-status/schema.ts
2598
- import z50 from "zod";
3152
+ import z53 from "zod";
2599
3153
  var PresenceStatusSchema = DefaultEntitySchema.extend({
2600
- status: z50.string(),
2601
- description: z50.string()
3154
+ status: z53.string(),
3155
+ description: z53.string()
2602
3156
  });
2603
3157
  var UserPresenceStatusSchema = DefaultEntitySchema.extend({
2604
3158
  user: UserSchema,
2605
3159
  presenceStatus: PresenceStatusSchema,
2606
- customPresenceStatus: z50.string().nullable().optional()
3160
+ customPresenceStatus: z53.string().nullable().optional()
2607
3161
  });
2608
3162
 
2609
3163
  // src/telephony-agent-presence-status/validation.ts
2610
- import { z as z51 } from "zod";
2611
- var UpdateUserStatusSchema = z51.object({
2612
- userId: z51.string(),
2613
- presenceStatusId: z51.string().nullable().optional(),
2614
- customPreseneStatus: z51.string().nullable().optional(),
2615
- reason: z51.string()
3164
+ import { z as z54 } from "zod";
3165
+ var UpdateUserStatusSchema = z54.object({
3166
+ userId: z54.string(),
3167
+ presenceStatusId: z54.string().nullable().optional(),
3168
+ customPreseneStatus: z54.string().nullable().optional(),
3169
+ reason: z54.string()
2616
3170
  });
2617
3171
 
2618
3172
  // src/telephony-agent-presence-status/index.ts
2619
- var telephonyAgentPresenceStatusContract = initContract21().router(
3173
+ var telephonyAgentPresenceStatusContract = initContract22().router(
2620
3174
  {
2621
3175
  getAllStatus: {
2622
3176
  method: "GET",
2623
3177
  path: "/presence_status",
2624
3178
  headers: DefaultHeaderSchema,
2625
3179
  responses: {
2626
- 200: z52.array(PresenceStatusSchema),
2627
- 400: z52.object({
2628
- message: z52.string()
3180
+ 200: z55.array(PresenceStatusSchema),
3181
+ 400: z55.object({
3182
+ message: z55.string()
2629
3183
  }),
2630
3184
  401: DefaultUnauthorizedSchema,
2631
3185
  500: DefaultErrorResponseSchema
@@ -2637,9 +3191,9 @@ var telephonyAgentPresenceStatusContract = initContract21().router(
2637
3191
  path: "/agents/presence_status",
2638
3192
  headers: DefaultHeaderSchema,
2639
3193
  responses: {
2640
- 200: z52.array(UserPresenceStatusSchema),
2641
- 400: z52.object({
2642
- message: z52.string()
3194
+ 200: z55.array(UserPresenceStatusSchema),
3195
+ 400: z55.object({
3196
+ message: z55.string()
2643
3197
  }),
2644
3198
  401: DefaultUnauthorizedSchema,
2645
3199
  500: DefaultErrorResponseSchema
@@ -2649,12 +3203,12 @@ var telephonyAgentPresenceStatusContract = initContract21().router(
2649
3203
  getAgentStatus: {
2650
3204
  method: "GET",
2651
3205
  path: "/presence_status/check_update/:userId",
2652
- pathParams: z52.object({ userId: z52.string() }),
3206
+ pathParams: z55.object({ userId: z55.string() }),
2653
3207
  headers: DefaultHeaderSchema,
2654
3208
  responses: {
2655
3209
  200: UserPresenceStatusSchema,
2656
- 400: z52.object({
2657
- message: z52.string()
3210
+ 400: z55.object({
3211
+ message: z55.string()
2658
3212
  }),
2659
3213
  401: DefaultUnauthorizedSchema,
2660
3214
  500: DefaultErrorResponseSchema
@@ -2670,8 +3224,8 @@ var telephonyAgentPresenceStatusContract = initContract21().router(
2670
3224
  200: DefaultSuccessResponseSchema.extend({
2671
3225
  userPresenceStatu: UserPresenceStatusSchema
2672
3226
  }),
2673
- 400: z52.object({
2674
- message: z52.string()
3227
+ 400: z55.object({
3228
+ message: z55.string()
2675
3229
  }),
2676
3230
  401: DefaultUnauthorizedSchema,
2677
3231
  500: DefaultErrorResponseSchema
@@ -2683,42 +3237,42 @@ var telephonyAgentPresenceStatusContract = initContract21().router(
2683
3237
  );
2684
3238
 
2685
3239
  // src/telephony-extension/index.ts
2686
- import { initContract as initContract22 } from "@ts-rest/core";
2687
- import z54 from "zod";
3240
+ import { initContract as initContract23 } from "@ts-rest/core";
3241
+ import z57 from "zod";
2688
3242
 
2689
3243
  // src/telephony-extension/schema.ts
2690
- import z53 from "zod";
2691
- var TelephonyExtensionSchema = z53.object({
2692
- errcode: z53.coerce.number(),
2693
- errmsg: z53.string(),
2694
- total_number: z53.coerce.number(),
2695
- data: z53.array(
2696
- z53.object({
2697
- id: z53.coerce.number(),
2698
- online_status: z53.object({
2699
- fx_phone: z53.object({ status: z53.coerce.number() }),
2700
- sip_phone: z53.object({
2701
- status: z53.coerce.number(),
2702
- ext_dev_type: z53.string().optional()
2703
- }),
2704
- linkus_desktop: z53.object({ status: z53.coerce.number() }),
2705
- linkus_mobile: z53.object({ status: z53.coerce.number() }),
2706
- linkus_web: z53.object({
2707
- status: z53.coerce.number(),
2708
- ext_dev_type: z53.string().optional()
3244
+ import z56 from "zod";
3245
+ var TelephonyExtensionSchema = z56.object({
3246
+ errcode: z56.coerce.number(),
3247
+ errmsg: z56.string(),
3248
+ total_number: z56.coerce.number(),
3249
+ data: z56.array(
3250
+ z56.object({
3251
+ id: z56.coerce.number(),
3252
+ online_status: z56.object({
3253
+ fx_phone: z56.object({ status: z56.coerce.number() }),
3254
+ sip_phone: z56.object({
3255
+ status: z56.coerce.number(),
3256
+ ext_dev_type: z56.string().optional()
3257
+ }),
3258
+ linkus_desktop: z56.object({ status: z56.coerce.number() }),
3259
+ linkus_mobile: z56.object({ status: z56.coerce.number() }),
3260
+ linkus_web: z56.object({
3261
+ status: z56.coerce.number(),
3262
+ ext_dev_type: z56.string().optional()
2709
3263
  })
2710
3264
  }).optional(),
2711
- presence_status: z53.string().optional(),
2712
- number: z53.string().optional(),
2713
- caller_id_name: z53.string().optional(),
2714
- role_name: z53.string().optional(),
2715
- email_addr: z53.string().optional()
3265
+ presence_status: z56.string().optional(),
3266
+ number: z56.string().optional(),
3267
+ caller_id_name: z56.string().optional(),
3268
+ role_name: z56.string().optional(),
3269
+ email_addr: z56.string().optional()
2716
3270
  })
2717
3271
  )
2718
3272
  });
2719
3273
 
2720
3274
  // src/telephony-extension/index.ts
2721
- var telephonyExtensionContract = initContract22().router(
3275
+ var telephonyExtensionContract = initContract23().router(
2722
3276
  {
2723
3277
  getTelephonyExtensions: {
2724
3278
  method: "GET",
@@ -2727,8 +3281,8 @@ var telephonyExtensionContract = initContract22().router(
2727
3281
  query: null,
2728
3282
  responses: {
2729
3283
  200: TelephonyExtensionSchema,
2730
- 400: z54.object({
2731
- message: z54.string()
3284
+ 400: z57.object({
3285
+ message: z57.string()
2732
3286
  }),
2733
3287
  401: DefaultUnauthorizedSchema,
2734
3288
  500: DefaultErrorResponseSchema
@@ -2740,26 +3294,26 @@ var telephonyExtensionContract = initContract22().router(
2740
3294
  );
2741
3295
 
2742
3296
  // src/user/index.ts
2743
- import { initContract as initContract23 } from "@ts-rest/core";
2744
- import z56 from "zod";
3297
+ import { initContract as initContract24 } from "@ts-rest/core";
3298
+ import z59 from "zod";
2745
3299
 
2746
3300
  // src/user/validation.ts
2747
- import { z as z55 } from "zod";
2748
- var CreateUserSchema = z55.object({
2749
- name: z55.string(),
2750
- email: z55.string().email(),
2751
- address: z55.string().nullable(),
2752
- phone: z55.string().nullable(),
2753
- password: z55.string(),
2754
- notificationCount: z55.number().nullable().optional(),
2755
- roles: z55.array(z55.string())
3301
+ import { z as z58 } from "zod";
3302
+ var CreateUserSchema = z58.object({
3303
+ name: z58.string(),
3304
+ email: z58.string().email(),
3305
+ address: z58.string().nullable(),
3306
+ phone: z58.string().nullable(),
3307
+ password: z58.string(),
3308
+ notificationCount: z58.number().nullable().optional(),
3309
+ roles: z58.array(z58.string())
2756
3310
  });
2757
3311
  var UpdateUserSchema = CreateUserSchema.extend({
2758
- newPassword: z55.string()
3312
+ newPassword: z58.string()
2759
3313
  });
2760
3314
 
2761
3315
  // src/user/index.ts
2762
- var userContract = initContract23().router(
3316
+ var userContract = initContract24().router(
2763
3317
  {
2764
3318
  createUser: {
2765
3319
  method: "POST",
@@ -2770,8 +3324,8 @@ var userContract = initContract23().router(
2770
3324
  201: DefaultSuccessResponseSchema.extend({
2771
3325
  user: UserSchema
2772
3326
  }),
2773
- 400: z56.object({
2774
- message: z56.string()
3327
+ 400: z59.object({
3328
+ message: z59.string()
2775
3329
  }),
2776
3330
  401: DefaultUnauthorizedSchema
2777
3331
  },
@@ -2781,15 +3335,15 @@ var userContract = initContract23().router(
2781
3335
  method: "GET",
2782
3336
  path: "",
2783
3337
  headers: DefaultHeaderSchema,
2784
- query: z56.object({
2785
- page: z56.coerce.number().default(1),
2786
- pageSize: z56.coerce.number().default(10),
2787
- keyword: z56.string().optional()
3338
+ query: z59.object({
3339
+ page: z59.coerce.number().default(1),
3340
+ pageSize: z59.coerce.number().default(10),
3341
+ keyword: z59.string().optional()
2788
3342
  }).optional(),
2789
3343
  responses: {
2790
3344
  200: WithPagination(UserSchema),
2791
- 400: z56.object({
2792
- message: z56.string()
3345
+ 400: z59.object({
3346
+ message: z59.string()
2793
3347
  }),
2794
3348
  401: DefaultUnauthorizedSchema,
2795
3349
  500: DefaultErrorResponseSchema
@@ -2799,12 +3353,12 @@ var userContract = initContract23().router(
2799
3353
  getUserById: {
2800
3354
  method: "GET",
2801
3355
  path: "/:id",
2802
- pathParams: z56.object({ id: z56.string() }),
3356
+ pathParams: z59.object({ id: z59.string() }),
2803
3357
  headers: DefaultHeaderSchema,
2804
3358
  responses: {
2805
3359
  200: UserSchema,
2806
- 400: z56.object({
2807
- message: z56.string()
3360
+ 400: z59.object({
3361
+ message: z59.string()
2808
3362
  }),
2809
3363
  401: DefaultUnauthorizedSchema
2810
3364
  },
@@ -2813,15 +3367,15 @@ var userContract = initContract23().router(
2813
3367
  updateUser: {
2814
3368
  method: "PATCH",
2815
3369
  path: "/:id",
2816
- pathParams: z56.object({ id: z56.string() }),
3370
+ pathParams: z59.object({ id: z59.string() }),
2817
3371
  headers: DefaultHeaderSchema,
2818
3372
  body: UpdateUserSchema,
2819
3373
  responses: {
2820
3374
  201: DefaultSuccessResponseSchema.extend({
2821
3375
  role: UserSchema
2822
3376
  }),
2823
- 400: z56.object({
2824
- message: z56.string()
3377
+ 400: z59.object({
3378
+ message: z59.string()
2825
3379
  }),
2826
3380
  401: DefaultUnauthorizedSchema
2827
3381
  },
@@ -2830,11 +3384,11 @@ var userContract = initContract23().router(
2830
3384
  deleteUser: {
2831
3385
  method: "DELETE",
2832
3386
  path: "/:id",
2833
- pathParams: z56.object({ id: z56.string() }),
3387
+ pathParams: z59.object({ id: z59.string() }),
2834
3388
  headers: DefaultHeaderSchema,
2835
3389
  body: null,
2836
3390
  responses: {
2837
- 200: DefaultSuccessResponseSchema.extend({ message: z56.string() }),
3391
+ 200: DefaultSuccessResponseSchema.extend({ message: z59.string() }),
2838
3392
  500: DefaultErrorResponseSchema
2839
3393
  },
2840
3394
  summary: "Delete a user."
@@ -2844,28 +3398,28 @@ var userContract = initContract23().router(
2844
3398
  );
2845
3399
 
2846
3400
  // src/user-presence-status-log/index.ts
2847
- import { initContract as initContract24 } from "@ts-rest/core";
2848
- import z59 from "zod";
3401
+ import { initContract as initContract25 } from "@ts-rest/core";
3402
+ import z62 from "zod";
2849
3403
 
2850
3404
  // src/user-presence-status-log/schema.ts
2851
- import z57 from "zod";
3405
+ import z60 from "zod";
2852
3406
  var UserPresenceStatusLogSchema = DefaultEntitySchema.extend({
2853
3407
  user: UserSchema,
2854
3408
  previousPresenceStatus: PresenceStatusSchema,
2855
3409
  newPresenceStatus: PresenceStatusSchema,
2856
- reason: z57.string()
3410
+ reason: z60.string()
2857
3411
  });
2858
3412
 
2859
3413
  // src/user-presence-status-log/validation.ts
2860
- import z58 from "zod";
2861
- var UserPresenceStatusLogParamsSchema = z58.object({
2862
- page: z58.coerce.number().default(1),
2863
- pageSize: z58.coerce.number().default(10),
2864
- selectedDate: z58.string().optional()
3414
+ import z61 from "zod";
3415
+ var UserPresenceStatusLogParamsSchema = z61.object({
3416
+ page: z61.coerce.number().default(1),
3417
+ pageSize: z61.coerce.number().default(10),
3418
+ selectedDate: z61.string().optional()
2865
3419
  }).optional();
2866
3420
 
2867
3421
  // src/user-presence-status-log/index.ts
2868
- var userPresenceStatusLogContract = initContract24().router(
3422
+ var userPresenceStatusLogContract = initContract25().router(
2869
3423
  {
2870
3424
  getUserPresenceStatusLog: {
2871
3425
  method: "GET",
@@ -2874,8 +3428,8 @@ var userPresenceStatusLogContract = initContract24().router(
2874
3428
  headers: DefaultHeaderSchema,
2875
3429
  responses: {
2876
3430
  200: WithPagination(UserPresenceStatusLogSchema),
2877
- 400: z59.object({
2878
- message: z59.string()
3431
+ 400: z62.object({
3432
+ message: z62.string()
2879
3433
  }),
2880
3434
  401: DefaultUnauthorizedSchema,
2881
3435
  500: DefaultErrorResponseSchema
@@ -2887,43 +3441,43 @@ var userPresenceStatusLogContract = initContract24().router(
2887
3441
  );
2888
3442
 
2889
3443
  // src/widget/index.ts
2890
- import { initContract as initContract25 } from "@ts-rest/core";
2891
- import z62 from "zod";
3444
+ import { initContract as initContract26 } from "@ts-rest/core";
3445
+ import z65 from "zod";
2892
3446
 
2893
3447
  // src/widget/schema.ts
2894
- import z60 from "zod";
2895
- var FieldsSchema = z60.object({ data: z60.array(z60.string()) });
2896
- var WidgetPositionSchema = z60.union([
2897
- z60.literal("menu"),
2898
- z60.literal("ticket_detail"),
2899
- z60.literal("contact_detail")
3448
+ import z63 from "zod";
3449
+ var FieldsSchema = z63.object({ data: z63.array(z63.string()) });
3450
+ var WidgetPositionSchema = z63.union([
3451
+ z63.literal("menu"),
3452
+ z63.literal("ticket_detail"),
3453
+ z63.literal("contact_detail")
2900
3454
  ]);
2901
3455
  var WidgetSchema = DefaultEntitySchema.extend({
2902
- name: z60.string(),
2903
- description: z60.string().nullable(),
3456
+ name: z63.string(),
3457
+ description: z63.string().nullable(),
2904
3458
  position: WidgetPositionSchema.nullable(),
2905
3459
  fields: FieldsSchema,
2906
- url: z60.string()
3460
+ url: z63.string()
2907
3461
  });
2908
3462
 
2909
3463
  // src/widget/validation.ts
2910
- import z61 from "zod";
2911
- var CreateWidgetSchema = z61.object({
2912
- name: z61.string(),
2913
- description: z61.string(),
2914
- url: z61.string(),
3464
+ import z64 from "zod";
3465
+ var CreateWidgetSchema = z64.object({
3466
+ name: z64.string(),
3467
+ description: z64.string(),
3468
+ url: z64.string(),
2915
3469
  position: WidgetPositionSchema,
2916
- fields: z61.object({
3470
+ fields: z64.object({
2917
3471
  data: (
2918
3472
  // Array of attribute system names
2919
- z61.array(z61.string())
3473
+ z64.array(z64.string())
2920
3474
  )
2921
3475
  }).optional()
2922
3476
  });
2923
3477
  var UpdateWidgetSchema = CreateWidgetSchema;
2924
3478
 
2925
3479
  // src/widget/index.ts
2926
- var widgetContract = initContract25().router(
3480
+ var widgetContract = initContract26().router(
2927
3481
  {
2928
3482
  createWidget: {
2929
3483
  method: "POST",
@@ -2934,8 +3488,8 @@ var widgetContract = initContract25().router(
2934
3488
  201: DefaultSuccessResponseSchema.extend({
2935
3489
  widget: WidgetSchema
2936
3490
  }),
2937
- 400: z62.object({
2938
- message: z62.string()
3491
+ 400: z65.object({
3492
+ message: z65.string()
2939
3493
  }),
2940
3494
  401: DefaultUnauthorizedSchema,
2941
3495
  500: DefaultErrorResponseSchema
@@ -2945,17 +3499,17 @@ var widgetContract = initContract25().router(
2945
3499
  getWidgets: {
2946
3500
  method: "GET",
2947
3501
  path: "",
2948
- query: z62.object({
2949
- page: z62.coerce.number().default(1),
2950
- pageSize: z62.coerce.number().default(10),
2951
- keyword: z62.coerce.string().optional()
3502
+ query: z65.object({
3503
+ page: z65.coerce.number().default(1),
3504
+ pageSize: z65.coerce.number().default(10),
3505
+ keyword: z65.coerce.string().optional()
2952
3506
  }).optional(),
2953
3507
  headers: DefaultHeaderSchema,
2954
3508
  responses: {
2955
3509
  200: WithPagination(WidgetSchema),
2956
3510
  500: DefaultErrorResponseSchema,
2957
- 400: z62.object({
2958
- message: z62.string()
3511
+ 400: z65.object({
3512
+ message: z65.string()
2959
3513
  }),
2960
3514
  401: DefaultUnauthorizedSchema
2961
3515
  },
@@ -2966,9 +3520,9 @@ var widgetContract = initContract25().router(
2966
3520
  path: "/menu",
2967
3521
  headers: DefaultHeaderSchema,
2968
3522
  responses: {
2969
- 200: z62.array(WidgetSchema),
2970
- 400: z62.object({
2971
- message: z62.string()
3523
+ 200: z65.array(WidgetSchema),
3524
+ 400: z65.object({
3525
+ message: z65.string()
2972
3526
  }),
2973
3527
  401: DefaultUnauthorizedSchema,
2974
3528
  500: DefaultErrorResponseSchema
@@ -2980,9 +3534,9 @@ var widgetContract = initContract25().router(
2980
3534
  path: "/ticket_detail",
2981
3535
  headers: DefaultHeaderSchema,
2982
3536
  responses: {
2983
- 200: z62.array(WidgetSchema),
2984
- 400: z62.object({
2985
- message: z62.string()
3537
+ 200: z65.array(WidgetSchema),
3538
+ 400: z65.object({
3539
+ message: z65.string()
2986
3540
  }),
2987
3541
  401: DefaultUnauthorizedSchema,
2988
3542
  500: DefaultErrorResponseSchema
@@ -2994,9 +3548,9 @@ var widgetContract = initContract25().router(
2994
3548
  path: "/contact_detail",
2995
3549
  headers: DefaultHeaderSchema,
2996
3550
  responses: {
2997
- 200: z62.array(WidgetSchema),
2998
- 400: z62.object({
2999
- message: z62.string()
3551
+ 200: z65.array(WidgetSchema),
3552
+ 400: z65.object({
3553
+ message: z65.string()
3000
3554
  }),
3001
3555
  401: DefaultUnauthorizedSchema,
3002
3556
  500: DefaultErrorResponseSchema
@@ -3006,12 +3560,12 @@ var widgetContract = initContract25().router(
3006
3560
  getWidgetById: {
3007
3561
  method: "GET",
3008
3562
  path: "/:id",
3009
- pathParams: z62.object({ id: z62.string() }),
3563
+ pathParams: z65.object({ id: z65.string() }),
3010
3564
  headers: DefaultHeaderSchema,
3011
3565
  responses: {
3012
3566
  200: WidgetSchema,
3013
- 400: z62.object({
3014
- message: z62.string()
3567
+ 400: z65.object({
3568
+ message: z65.string()
3015
3569
  }),
3016
3570
  401: DefaultUnauthorizedSchema,
3017
3571
  500: DefaultErrorResponseSchema
@@ -3045,14 +3599,14 @@ var widgetContract = initContract25().router(
3045
3599
  updateWidget: {
3046
3600
  method: "PATCH",
3047
3601
  path: "/:id",
3048
- pathParams: z62.object({ id: z62.string() }),
3602
+ pathParams: z65.object({ id: z65.string() }),
3049
3603
  headers: DefaultHeaderSchema,
3050
3604
  responses: {
3051
3605
  201: DefaultSuccessResponseSchema.extend({
3052
3606
  widget: WidgetSchema
3053
3607
  }),
3054
- 400: z62.object({
3055
- message: z62.string()
3608
+ 400: z65.object({
3609
+ message: z65.string()
3056
3610
  }),
3057
3611
  401: DefaultUnauthorizedSchema
3058
3612
  },
@@ -3062,11 +3616,11 @@ var widgetContract = initContract25().router(
3062
3616
  deleteWidget: {
3063
3617
  method: "DELETE",
3064
3618
  path: "/:id",
3065
- pathParams: z62.object({ id: z62.string() }),
3619
+ pathParams: z65.object({ id: z65.string() }),
3066
3620
  headers: DefaultHeaderSchema,
3067
3621
  body: null,
3068
3622
  responses: {
3069
- 200: DefaultSuccessResponseSchema.extend({ message: z62.string() }),
3623
+ 200: DefaultSuccessResponseSchema.extend({ message: z65.string() }),
3070
3624
  500: DefaultErrorResponseSchema
3071
3625
  },
3072
3626
  summary: "Delete a widget."
@@ -3076,33 +3630,33 @@ var widgetContract = initContract25().router(
3076
3630
  );
3077
3631
 
3078
3632
  // src/wrap-up-form/index.ts
3079
- import { initContract as initContract26 } from "@ts-rest/core";
3080
- import z65 from "zod";
3633
+ import { initContract as initContract27 } from "@ts-rest/core";
3634
+ import z68 from "zod";
3081
3635
 
3082
3636
  // src/wrap-up-form/schema.ts
3083
- import z63 from "zod";
3637
+ import z66 from "zod";
3084
3638
  var WrapUpFormSchema = DefaultEntitySchema.extend({
3085
- note: z63.string().nullable(),
3086
- disposition: z63.string().nullable(),
3087
- callFrom: z63.string().nullable(),
3088
- callTo: z63.string().nullable(),
3089
- tags: z63.array(TagSchema)
3639
+ note: z66.string().nullable(),
3640
+ disposition: z66.string().nullable(),
3641
+ callFrom: z66.string().nullable(),
3642
+ callTo: z66.string().nullable(),
3643
+ tags: z66.array(TagSchema)
3090
3644
  });
3091
3645
 
3092
3646
  // src/wrap-up-form/validation.ts
3093
- import { z as z64 } from "zod";
3094
- var CreateWrapUpFormSchema = z64.object({
3095
- note: z64.string().nullable().optional(),
3096
- disposition: z64.string().nullable().optional(),
3097
- callFrom: z64.string().nullable().optional(),
3098
- callTo: z64.string().nullable().optional()
3647
+ import { z as z67 } from "zod";
3648
+ var CreateWrapUpFormSchema = z67.object({
3649
+ note: z67.string().nullable().optional(),
3650
+ disposition: z67.string().nullable().optional(),
3651
+ callFrom: z67.string().nullable().optional(),
3652
+ callTo: z67.string().nullable().optional()
3099
3653
  });
3100
3654
  var UpdateWrapUpFormSchema = CreateWrapUpFormSchema.extend({
3101
- tags: z64.array(z64.string()).optional()
3655
+ tags: z67.array(z67.string()).optional()
3102
3656
  });
3103
3657
 
3104
3658
  // src/wrap-up-form/index.ts
3105
- var wrapUpFormContract = initContract26().router(
3659
+ var wrapUpFormContract = initContract27().router(
3106
3660
  {
3107
3661
  createWrapUpForm: {
3108
3662
  method: "POST",
@@ -3113,8 +3667,8 @@ var wrapUpFormContract = initContract26().router(
3113
3667
  201: DefaultSuccessResponseSchema.extend({
3114
3668
  wrapUpForm: WrapUpFormSchema
3115
3669
  }),
3116
- 400: z65.object({
3117
- message: z65.string()
3670
+ 400: z68.object({
3671
+ message: z68.string()
3118
3672
  }),
3119
3673
  401: DefaultUnauthorizedSchema,
3120
3674
  500: DefaultErrorResponseSchema
@@ -3124,15 +3678,15 @@ var wrapUpFormContract = initContract26().router(
3124
3678
  getWrapUpForms: {
3125
3679
  method: "GET",
3126
3680
  path: "",
3127
- query: z65.object({
3128
- page: z65.coerce.number().default(1),
3129
- pageSize: z65.coerce.number().default(10)
3681
+ query: z68.object({
3682
+ page: z68.coerce.number().default(1),
3683
+ pageSize: z68.coerce.number().default(10)
3130
3684
  }).optional(),
3131
3685
  headers: DefaultHeaderSchema,
3132
3686
  responses: {
3133
3687
  200: WithPagination(WrapUpFormSchema),
3134
- 400: z65.object({
3135
- message: z65.string()
3688
+ 400: z68.object({
3689
+ message: z68.string()
3136
3690
  }),
3137
3691
  401: DefaultUnauthorizedSchema,
3138
3692
  500: DefaultErrorResponseSchema
@@ -3142,15 +3696,15 @@ var wrapUpFormContract = initContract26().router(
3142
3696
  updateWrapUpForm: {
3143
3697
  method: "PATCH",
3144
3698
  path: "/:id",
3145
- pathParams: z65.object({ id: z65.string() }),
3699
+ pathParams: z68.object({ id: z68.string() }),
3146
3700
  headers: DefaultHeaderSchema,
3147
3701
  body: UpdateWrapUpFormSchema,
3148
3702
  responses: {
3149
3703
  201: DefaultSuccessResponseSchema.extend({
3150
3704
  wrapUpForm: WrapUpFormSchema
3151
3705
  }),
3152
- 400: z65.object({
3153
- message: z65.string()
3706
+ 400: z68.object({
3707
+ message: z68.string()
3154
3708
  }),
3155
3709
  401: DefaultUnauthorizedSchema,
3156
3710
  500: DefaultErrorResponseSchema
@@ -3162,7 +3716,7 @@ var wrapUpFormContract = initContract26().router(
3162
3716
  );
3163
3717
 
3164
3718
  // src/contract.ts
3165
- var apiContract = initContract27().router({
3719
+ var apiContract = initContract28().router({
3166
3720
  auth: authContract,
3167
3721
  mail: mailContract,
3168
3722
  cxLog: cxLogContract,
@@ -3181,13 +3735,14 @@ var apiContract = initContract27().router({
3181
3735
  aws: awsContract,
3182
3736
  agentPresenceStatus: telephonyAgentPresenceStatusContract,
3183
3737
  userPresenceStatusLog: userPresenceStatusLogContract,
3184
- contact: contactContract
3738
+ contact: contactContract,
3739
+ ticket: ticketContract
3185
3740
  });
3186
- var platformContract = initContract27().router({
3741
+ var platformContract = initContract28().router({
3187
3742
  line: lineContract,
3188
3743
  messenger: messengerContract
3189
3744
  });
3190
- var chatContract = initContract27().router({
3745
+ var chatContract = initContract28().router({
3191
3746
  main: mainChatContract
3192
3747
  });
3193
3748
  export {