@kl1/contracts 1.3.10 → 1.3.12
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/api-contracts/src/contract.d.ts +171 -10
 - package/dist/api-contracts/src/contract.d.ts.map +1 -1
 - package/dist/api-contracts/src/dashboard/index.d.ts +171 -10
 - package/dist/api-contracts/src/dashboard/index.d.ts.map +1 -1
 - package/dist/api-contracts/src/presence-status/index.d.ts +1 -1
 - package/dist/api-contracts/src/presence-status/index.d.ts.map +1 -1
 - package/dist/index.js +66 -10
 - package/dist/index.js.map +1 -1
 - package/dist/index.mjs +66 -10
 - package/dist/index.mjs.map +1 -1
 - package/package.json +1 -1
 
| 
         @@ -25410,6 +25410,32 @@ export declare const apiContract: { 
     | 
|
| 
       25410 
25410 
     | 
    
         
             
                            'x-client-timezone'?: string | undefined;
         
     | 
| 
       25411 
25411 
     | 
    
         
             
                        }>>>;
         
     | 
| 
       25412 
25412 
     | 
    
         
             
                    };
         
     | 
| 
      
 25413 
     | 
    
         
            +
                    exportRoomTagCounts: {
         
     | 
| 
      
 25414 
     | 
    
         
            +
                        body: import("zod").ZodObject<{
         
     | 
| 
      
 25415 
     | 
    
         
            +
                            automationQueueId: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
      
 25416 
     | 
    
         
            +
                            selectedDate: import("zod").ZodString;
         
     | 
| 
      
 25417 
     | 
    
         
            +
                            channelIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
         
     | 
| 
      
 25418 
     | 
    
         
            +
                        }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 25419 
     | 
    
         
            +
                            selectedDate: string;
         
     | 
| 
      
 25420 
     | 
    
         
            +
                            automationQueueId?: string | undefined;
         
     | 
| 
      
 25421 
     | 
    
         
            +
                            channelIds?: string[] | undefined;
         
     | 
| 
      
 25422 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 25423 
     | 
    
         
            +
                            selectedDate: string;
         
     | 
| 
      
 25424 
     | 
    
         
            +
                            automationQueueId?: string | undefined;
         
     | 
| 
      
 25425 
     | 
    
         
            +
                            channelIds?: string[] | undefined;
         
     | 
| 
      
 25426 
     | 
    
         
            +
                        }>;
         
     | 
| 
      
 25427 
     | 
    
         
            +
                        method: "POST";
         
     | 
| 
      
 25428 
     | 
    
         
            +
                        responses: {
         
     | 
| 
      
 25429 
     | 
    
         
            +
                            200: import("zod").ZodObject<{
         
     | 
| 
      
 25430 
     | 
    
         
            +
                                requestId: import("zod").ZodString;
         
     | 
| 
      
 25431 
     | 
    
         
            +
                            }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 25432 
     | 
    
         
            +
                                requestId: string;
         
     | 
| 
      
 25433 
     | 
    
         
            +
                            }, {
         
     | 
| 
      
 25434 
     | 
    
         
            +
                                requestId: string;
         
     | 
| 
      
 25435 
     | 
    
         
            +
                            }>;
         
     | 
| 
      
 25436 
     | 
    
         
            +
                        };
         
     | 
| 
      
 25437 
     | 
    
         
            +
                        path: "ms/dashboard/export-room-tag-counts";
         
     | 
| 
      
 25438 
     | 
    
         
            +
                    };
         
     | 
| 
       25413 
25439 
     | 
    
         
             
                    getCallTagData: {
         
     | 
| 
       25414 
25440 
     | 
    
         
             
                        summary: "Get call tag data";
         
     | 
| 
       25415 
25441 
     | 
    
         
             
                        method: "GET";
         
     | 
| 
         @@ -25891,8 +25917,7 @@ export declare const apiContract: { 
     | 
|
| 
       25891 
25917 
     | 
    
         
             
                        }>>>;
         
     | 
| 
       25892 
25918 
     | 
    
         
             
                    };
         
     | 
| 
       25893 
25919 
     | 
    
         
             
                    exportMessageAverageData: {
         
     | 
| 
       25894 
     | 
    
         
            -
                         
     | 
| 
       25895 
     | 
    
         
            -
                        query: import("zod").ZodObject<{
         
     | 
| 
      
 25920 
     | 
    
         
            +
                        body: import("zod").ZodObject<{
         
     | 
| 
       25896 
25921 
     | 
    
         
             
                            selectedDate: import("zod").ZodString;
         
     | 
| 
       25897 
25922 
     | 
    
         
             
                            automationQueueId: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
       25898 
25923 
     | 
    
         
             
                            channelIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
         
     | 
| 
         @@ -25905,6 +25930,7 @@ export declare const apiContract: { 
     | 
|
| 
       25905 
25930 
     | 
    
         
             
                            automationQueueId?: string | undefined;
         
     | 
| 
       25906 
25931 
     | 
    
         
             
                            channelIds?: string[] | undefined;
         
     | 
| 
       25907 
25932 
     | 
    
         
             
                        }>;
         
     | 
| 
      
 25933 
     | 
    
         
            +
                        method: "POST";
         
     | 
| 
       25908 
25934 
     | 
    
         
             
                        responses: {
         
     | 
| 
       25909 
25935 
     | 
    
         
             
                            200: import("zod").ZodObject<{
         
     | 
| 
       25910 
25936 
     | 
    
         
             
                                requestId: import("zod").ZodString;
         
     | 
| 
         @@ -25988,8 +26014,7 @@ export declare const apiContract: { 
     | 
|
| 
       25988 
26014 
     | 
    
         
             
                        }>>>;
         
     | 
| 
       25989 
26015 
     | 
    
         
             
                    };
         
     | 
| 
       25990 
26016 
     | 
    
         
             
                    exportRoomChannelCounts: {
         
     | 
| 
       25991 
     | 
    
         
            -
                         
     | 
| 
       25992 
     | 
    
         
            -
                        query: import("zod").ZodObject<{
         
     | 
| 
      
 26017 
     | 
    
         
            +
                        body: import("zod").ZodObject<{
         
     | 
| 
       25993 
26018 
     | 
    
         
             
                            automationQueueId: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
       25994 
26019 
     | 
    
         
             
                            selectedDate: import("zod").ZodString;
         
     | 
| 
       25995 
26020 
     | 
    
         
             
                            channelIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
         
     | 
| 
         @@ -26002,6 +26027,7 @@ export declare const apiContract: { 
     | 
|
| 
       26002 
26027 
     | 
    
         
             
                            automationQueueId?: string | undefined;
         
     | 
| 
       26003 
26028 
     | 
    
         
             
                            channelIds?: string[] | undefined;
         
     | 
| 
       26004 
26029 
     | 
    
         
             
                        }>;
         
     | 
| 
      
 26030 
     | 
    
         
            +
                        method: "POST";
         
     | 
| 
       26005 
26031 
     | 
    
         
             
                        responses: {
         
     | 
| 
       26006 
26032 
     | 
    
         
             
                            200: import("zod").ZodObject<{
         
     | 
| 
       26007 
26033 
     | 
    
         
             
                                requestId: import("zod").ZodString;
         
     | 
| 
         @@ -26084,6 +26110,32 @@ export declare const apiContract: { 
     | 
|
| 
       26084 
26110 
     | 
    
         
             
                            'x-client-timezone'?: string | undefined;
         
     | 
| 
       26085 
26111 
     | 
    
         
             
                        }>>>;
         
     | 
| 
       26086 
26112 
     | 
    
         
             
                    };
         
     | 
| 
      
 26113 
     | 
    
         
            +
                    exportRoomDispositionCounts: {
         
     | 
| 
      
 26114 
     | 
    
         
            +
                        body: import("zod").ZodObject<{
         
     | 
| 
      
 26115 
     | 
    
         
            +
                            automationQueueId: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
      
 26116 
     | 
    
         
            +
                            selectedDate: import("zod").ZodString;
         
     | 
| 
      
 26117 
     | 
    
         
            +
                            channelIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
         
     | 
| 
      
 26118 
     | 
    
         
            +
                        }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 26119 
     | 
    
         
            +
                            selectedDate: string;
         
     | 
| 
      
 26120 
     | 
    
         
            +
                            automationQueueId?: string | undefined;
         
     | 
| 
      
 26121 
     | 
    
         
            +
                            channelIds?: string[] | undefined;
         
     | 
| 
      
 26122 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 26123 
     | 
    
         
            +
                            selectedDate: string;
         
     | 
| 
      
 26124 
     | 
    
         
            +
                            automationQueueId?: string | undefined;
         
     | 
| 
      
 26125 
     | 
    
         
            +
                            channelIds?: string[] | undefined;
         
     | 
| 
      
 26126 
     | 
    
         
            +
                        }>;
         
     | 
| 
      
 26127 
     | 
    
         
            +
                        method: "POST";
         
     | 
| 
      
 26128 
     | 
    
         
            +
                        responses: {
         
     | 
| 
      
 26129 
     | 
    
         
            +
                            200: import("zod").ZodObject<{
         
     | 
| 
      
 26130 
     | 
    
         
            +
                                requestId: import("zod").ZodString;
         
     | 
| 
      
 26131 
     | 
    
         
            +
                            }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 26132 
     | 
    
         
            +
                                requestId: string;
         
     | 
| 
      
 26133 
     | 
    
         
            +
                            }, {
         
     | 
| 
      
 26134 
     | 
    
         
            +
                                requestId: string;
         
     | 
| 
      
 26135 
     | 
    
         
            +
                            }>;
         
     | 
| 
      
 26136 
     | 
    
         
            +
                        };
         
     | 
| 
      
 26137 
     | 
    
         
            +
                        path: "ms/dashboard/export-room-disposition-counts";
         
     | 
| 
      
 26138 
     | 
    
         
            +
                    };
         
     | 
| 
       26087 
26139 
     | 
    
         
             
                    getIncomingMessageByPlatform: {
         
     | 
| 
       26088 
26140 
     | 
    
         
             
                        summary: "Get incoming message by platform";
         
     | 
| 
       26089 
26141 
     | 
    
         
             
                        method: "GET";
         
     | 
| 
         @@ -26235,8 +26287,7 @@ export declare const apiContract: { 
     | 
|
| 
       26235 
26287 
     | 
    
         
             
                        }>>>;
         
     | 
| 
       26236 
26288 
     | 
    
         
             
                    };
         
     | 
| 
       26237 
26289 
     | 
    
         
             
                    exportIncomingMessageCounts: {
         
     | 
| 
       26238 
     | 
    
         
            -
                         
     | 
| 
       26239 
     | 
    
         
            -
                        query: import("zod").ZodObject<{
         
     | 
| 
      
 26290 
     | 
    
         
            +
                        body: import("zod").ZodObject<{
         
     | 
| 
       26240 
26291 
     | 
    
         
             
                            automationQueueId: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
       26241 
26292 
     | 
    
         
             
                            selectedDate: import("zod").ZodString;
         
     | 
| 
       26242 
26293 
     | 
    
         
             
                            channelIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
         
     | 
| 
         @@ -26249,6 +26300,7 @@ export declare const apiContract: { 
     | 
|
| 
       26249 
26300 
     | 
    
         
             
                            automationQueueId?: string | undefined;
         
     | 
| 
       26250 
26301 
     | 
    
         
             
                            channelIds?: string[] | undefined;
         
     | 
| 
       26251 
26302 
     | 
    
         
             
                        }>;
         
     | 
| 
      
 26303 
     | 
    
         
            +
                        method: "POST";
         
     | 
| 
       26252 
26304 
     | 
    
         
             
                        responses: {
         
     | 
| 
       26253 
26305 
     | 
    
         
             
                            200: import("zod").ZodObject<{
         
     | 
| 
       26254 
26306 
     | 
    
         
             
                                requestId: import("zod").ZodString;
         
     | 
| 
         @@ -26600,8 +26652,7 @@ export declare const apiContract: { 
     | 
|
| 
       26600 
26652 
     | 
    
         
             
                        path: "ms/dashboard/agent-message-statistics";
         
     | 
| 
       26601 
26653 
     | 
    
         
             
                    };
         
     | 
| 
       26602 
26654 
     | 
    
         
             
                    exportAgentMessageStatistics: {
         
     | 
| 
       26603 
     | 
    
         
            -
                         
     | 
| 
       26604 
     | 
    
         
            -
                        query: import("zod").ZodObject<{
         
     | 
| 
      
 26655 
     | 
    
         
            +
                        body: import("zod").ZodObject<{
         
     | 
| 
       26605 
26656 
     | 
    
         
             
                            automationQueueId: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
       26606 
26657 
     | 
    
         
             
                            selectedDate: import("zod").ZodString;
         
     | 
| 
       26607 
26658 
     | 
    
         
             
                            channelIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
         
     | 
| 
         @@ -26614,6 +26665,7 @@ export declare const apiContract: { 
     | 
|
| 
       26614 
26665 
     | 
    
         
             
                            automationQueueId?: string | undefined;
         
     | 
| 
       26615 
26666 
     | 
    
         
             
                            channelIds?: string[] | undefined;
         
     | 
| 
       26616 
26667 
     | 
    
         
             
                        }>;
         
     | 
| 
      
 26668 
     | 
    
         
            +
                        method: "POST";
         
     | 
| 
       26617 
26669 
     | 
    
         
             
                        responses: {
         
     | 
| 
       26618 
26670 
     | 
    
         
             
                            200: import("zod").ZodObject<{
         
     | 
| 
       26619 
26671 
     | 
    
         
             
                                requestId: import("zod").ZodString;
         
     | 
| 
         @@ -26743,8 +26795,7 @@ export declare const apiContract: { 
     | 
|
| 
       26743 
26795 
     | 
    
         
             
                        path: "ms/dashboard/user-check-in-logs-with-days";
         
     | 
| 
       26744 
26796 
     | 
    
         
             
                    };
         
     | 
| 
       26745 
26797 
     | 
    
         
             
                    exportUserCheckInLogs: {
         
     | 
| 
       26746 
     | 
    
         
            -
                         
     | 
| 
       26747 
     | 
    
         
            -
                        query: import("zod").ZodObject<{
         
     | 
| 
      
 26798 
     | 
    
         
            +
                        body: import("zod").ZodObject<{
         
     | 
| 
       26748 
26799 
     | 
    
         
             
                            automationQueueId: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
       26749 
26800 
     | 
    
         
             
                            selectedDate: import("zod").ZodString;
         
     | 
| 
       26750 
26801 
     | 
    
         
             
                            keyword: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
         @@ -26757,6 +26808,7 @@ export declare const apiContract: { 
     | 
|
| 
       26757 
26808 
     | 
    
         
             
                            automationQueueId?: string | undefined;
         
     | 
| 
       26758 
26809 
     | 
    
         
             
                            keyword?: string | undefined;
         
     | 
| 
       26759 
26810 
     | 
    
         
             
                        }>;
         
     | 
| 
      
 26811 
     | 
    
         
            +
                        method: "POST";
         
     | 
| 
       26760 
26812 
     | 
    
         
             
                        responses: {
         
     | 
| 
       26761 
26813 
     | 
    
         
             
                            200: import("zod").ZodObject<{
         
     | 
| 
       26762 
26814 
     | 
    
         
             
                                requestId: import("zod").ZodString;
         
     | 
| 
         @@ -26803,20 +26855,106 @@ export declare const apiContract: { 
     | 
|
| 
       26803 
26855 
     | 
    
         
             
                        };
         
     | 
| 
       26804 
26856 
     | 
    
         
             
                        path: "ms/dashboard/room-status-counts-by-user-id";
         
     | 
| 
       26805 
26857 
     | 
    
         
             
                    };
         
     | 
| 
      
 26858 
     | 
    
         
            +
                    getPresenceStatusDurations: {
         
     | 
| 
      
 26859 
     | 
    
         
            +
                        method: "GET";
         
     | 
| 
      
 26860 
     | 
    
         
            +
                        query: import("zod").ZodObject<{
         
     | 
| 
      
 26861 
     | 
    
         
            +
                            userId: import("zod").ZodString;
         
     | 
| 
      
 26862 
     | 
    
         
            +
                            selectedDate: import("zod").ZodString;
         
     | 
| 
      
 26863 
     | 
    
         
            +
                            page: import("zod").ZodNumber;
         
     | 
| 
      
 26864 
     | 
    
         
            +
                            pageSize: import("zod").ZodNumber;
         
     | 
| 
      
 26865 
     | 
    
         
            +
                        }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 26866 
     | 
    
         
            +
                            page: number;
         
     | 
| 
      
 26867 
     | 
    
         
            +
                            pageSize: number;
         
     | 
| 
      
 26868 
     | 
    
         
            +
                            userId: string;
         
     | 
| 
      
 26869 
     | 
    
         
            +
                            selectedDate: string;
         
     | 
| 
      
 26870 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 26871 
     | 
    
         
            +
                            page: number;
         
     | 
| 
      
 26872 
     | 
    
         
            +
                            pageSize: number;
         
     | 
| 
      
 26873 
     | 
    
         
            +
                            userId: string;
         
     | 
| 
      
 26874 
     | 
    
         
            +
                            selectedDate: string;
         
     | 
| 
      
 26875 
     | 
    
         
            +
                        }>;
         
     | 
| 
      
 26876 
     | 
    
         
            +
                        responses: {
         
     | 
| 
      
 26877 
     | 
    
         
            +
                            200: import("zod").ZodObject<{
         
     | 
| 
      
 26878 
     | 
    
         
            +
                                requestId: import("zod").ZodString;
         
     | 
| 
      
 26879 
     | 
    
         
            +
                                presenceStatusDurations: import("zod").ZodArray<import("zod").ZodObject<{
         
     | 
| 
      
 26880 
     | 
    
         
            +
                                    formattedDate: import("zod").ZodString;
         
     | 
| 
      
 26881 
     | 
    
         
            +
                                    date: import("zod").ZodDate;
         
     | 
| 
      
 26882 
     | 
    
         
            +
                                    durations: import("zod").ZodArray<import("zod").ZodObject<{
         
     | 
| 
      
 26883 
     | 
    
         
            +
                                        presenceStatusName: import("zod").ZodString;
         
     | 
| 
      
 26884 
     | 
    
         
            +
                                        durationSeconds: import("zod").ZodNumber;
         
     | 
| 
      
 26885 
     | 
    
         
            +
                                        formattedDuration: import("zod").ZodString;
         
     | 
| 
      
 26886 
     | 
    
         
            +
                                    }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 26887 
     | 
    
         
            +
                                        formattedDuration: string;
         
     | 
| 
      
 26888 
     | 
    
         
            +
                                        presenceStatusName: string;
         
     | 
| 
      
 26889 
     | 
    
         
            +
                                        durationSeconds: number;
         
     | 
| 
      
 26890 
     | 
    
         
            +
                                    }, {
         
     | 
| 
      
 26891 
     | 
    
         
            +
                                        formattedDuration: string;
         
     | 
| 
      
 26892 
     | 
    
         
            +
                                        presenceStatusName: string;
         
     | 
| 
      
 26893 
     | 
    
         
            +
                                        durationSeconds: number;
         
     | 
| 
      
 26894 
     | 
    
         
            +
                                    }>, "many">;
         
     | 
| 
      
 26895 
     | 
    
         
            +
                                }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 26896 
     | 
    
         
            +
                                    date: Date;
         
     | 
| 
      
 26897 
     | 
    
         
            +
                                    formattedDate: string;
         
     | 
| 
      
 26898 
     | 
    
         
            +
                                    durations: {
         
     | 
| 
      
 26899 
     | 
    
         
            +
                                        formattedDuration: string;
         
     | 
| 
      
 26900 
     | 
    
         
            +
                                        presenceStatusName: string;
         
     | 
| 
      
 26901 
     | 
    
         
            +
                                        durationSeconds: number;
         
     | 
| 
      
 26902 
     | 
    
         
            +
                                    }[];
         
     | 
| 
      
 26903 
     | 
    
         
            +
                                }, {
         
     | 
| 
      
 26904 
     | 
    
         
            +
                                    date: Date;
         
     | 
| 
      
 26905 
     | 
    
         
            +
                                    formattedDate: string;
         
     | 
| 
      
 26906 
     | 
    
         
            +
                                    durations: {
         
     | 
| 
      
 26907 
     | 
    
         
            +
                                        formattedDuration: string;
         
     | 
| 
      
 26908 
     | 
    
         
            +
                                        presenceStatusName: string;
         
     | 
| 
      
 26909 
     | 
    
         
            +
                                        durationSeconds: number;
         
     | 
| 
      
 26910 
     | 
    
         
            +
                                    }[];
         
     | 
| 
      
 26911 
     | 
    
         
            +
                                }>, "many">;
         
     | 
| 
      
 26912 
     | 
    
         
            +
                            }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 26913 
     | 
    
         
            +
                                requestId: string;
         
     | 
| 
      
 26914 
     | 
    
         
            +
                                presenceStatusDurations: {
         
     | 
| 
      
 26915 
     | 
    
         
            +
                                    date: Date;
         
     | 
| 
      
 26916 
     | 
    
         
            +
                                    formattedDate: string;
         
     | 
| 
      
 26917 
     | 
    
         
            +
                                    durations: {
         
     | 
| 
      
 26918 
     | 
    
         
            +
                                        formattedDuration: string;
         
     | 
| 
      
 26919 
     | 
    
         
            +
                                        presenceStatusName: string;
         
     | 
| 
      
 26920 
     | 
    
         
            +
                                        durationSeconds: number;
         
     | 
| 
      
 26921 
     | 
    
         
            +
                                    }[];
         
     | 
| 
      
 26922 
     | 
    
         
            +
                                }[];
         
     | 
| 
      
 26923 
     | 
    
         
            +
                            }, {
         
     | 
| 
      
 26924 
     | 
    
         
            +
                                requestId: string;
         
     | 
| 
      
 26925 
     | 
    
         
            +
                                presenceStatusDurations: {
         
     | 
| 
      
 26926 
     | 
    
         
            +
                                    date: Date;
         
     | 
| 
      
 26927 
     | 
    
         
            +
                                    formattedDate: string;
         
     | 
| 
      
 26928 
     | 
    
         
            +
                                    durations: {
         
     | 
| 
      
 26929 
     | 
    
         
            +
                                        formattedDuration: string;
         
     | 
| 
      
 26930 
     | 
    
         
            +
                                        presenceStatusName: string;
         
     | 
| 
      
 26931 
     | 
    
         
            +
                                        durationSeconds: number;
         
     | 
| 
      
 26932 
     | 
    
         
            +
                                    }[];
         
     | 
| 
      
 26933 
     | 
    
         
            +
                                }[];
         
     | 
| 
      
 26934 
     | 
    
         
            +
                            }>;
         
     | 
| 
      
 26935 
     | 
    
         
            +
                        };
         
     | 
| 
      
 26936 
     | 
    
         
            +
                        path: "ms/dashboard/presence-status-durations";
         
     | 
| 
      
 26937 
     | 
    
         
            +
                    };
         
     | 
| 
       26806 
26938 
     | 
    
         
             
                    getUserCheckInLogsByUserId: {
         
     | 
| 
       26807 
26939 
     | 
    
         
             
                        method: "GET";
         
     | 
| 
       26808 
26940 
     | 
    
         
             
                        query: import("zod").ZodObject<{
         
     | 
| 
      
 26941 
     | 
    
         
            +
                            automationQueueId: import("zod").ZodOptional<import("zod").ZodString>;
         
     | 
| 
       26809 
26942 
     | 
    
         
             
                            userId: import("zod").ZodString;
         
     | 
| 
       26810 
26943 
     | 
    
         
             
                            selectedDate: import("zod").ZodString;
         
     | 
| 
      
 26944 
     | 
    
         
            +
                            page: import("zod").ZodNumber;
         
     | 
| 
       26811 
26945 
     | 
    
         
             
                            pageSize: import("zod").ZodNumber;
         
     | 
| 
       26812 
26946 
     | 
    
         
             
                        }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 26947 
     | 
    
         
            +
                            page: number;
         
     | 
| 
       26813 
26948 
     | 
    
         
             
                            pageSize: number;
         
     | 
| 
       26814 
26949 
     | 
    
         
             
                            userId: string;
         
     | 
| 
       26815 
26950 
     | 
    
         
             
                            selectedDate: string;
         
     | 
| 
      
 26951 
     | 
    
         
            +
                            automationQueueId?: string | undefined;
         
     | 
| 
       26816 
26952 
     | 
    
         
             
                        }, {
         
     | 
| 
      
 26953 
     | 
    
         
            +
                            page: number;
         
     | 
| 
       26817 
26954 
     | 
    
         
             
                            pageSize: number;
         
     | 
| 
       26818 
26955 
     | 
    
         
             
                            userId: string;
         
     | 
| 
       26819 
26956 
     | 
    
         
             
                            selectedDate: string;
         
     | 
| 
      
 26957 
     | 
    
         
            +
                            automationQueueId?: string | undefined;
         
     | 
| 
       26820 
26958 
     | 
    
         
             
                        }>;
         
     | 
| 
       26821 
26959 
     | 
    
         
             
                        responses: {
         
     | 
| 
       26822 
26960 
     | 
    
         
             
                            200: import("zod").ZodObject<{
         
     | 
| 
         @@ -26908,6 +27046,29 @@ export declare const apiContract: { 
     | 
|
| 
       26908 
27046 
     | 
    
         
             
                        };
         
     | 
| 
       26909 
27047 
     | 
    
         
             
                        path: "ms/dashboard/user-check-in-logs-by-user-id";
         
     | 
| 
       26910 
27048 
     | 
    
         
             
                    };
         
     | 
| 
      
 27049 
     | 
    
         
            +
                    exportUserCheckInLogsByUserId: {
         
     | 
| 
      
 27050 
     | 
    
         
            +
                        body: import("zod").ZodObject<{
         
     | 
| 
      
 27051 
     | 
    
         
            +
                            userId: import("zod").ZodString;
         
     | 
| 
      
 27052 
     | 
    
         
            +
                            selectedDate: import("zod").ZodString;
         
     | 
| 
      
 27053 
     | 
    
         
            +
                        }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 27054 
     | 
    
         
            +
                            userId: string;
         
     | 
| 
      
 27055 
     | 
    
         
            +
                            selectedDate: string;
         
     | 
| 
      
 27056 
     | 
    
         
            +
                        }, {
         
     | 
| 
      
 27057 
     | 
    
         
            +
                            userId: string;
         
     | 
| 
      
 27058 
     | 
    
         
            +
                            selectedDate: string;
         
     | 
| 
      
 27059 
     | 
    
         
            +
                        }>;
         
     | 
| 
      
 27060 
     | 
    
         
            +
                        method: "POST";
         
     | 
| 
      
 27061 
     | 
    
         
            +
                        responses: {
         
     | 
| 
      
 27062 
     | 
    
         
            +
                            200: import("zod").ZodObject<{
         
     | 
| 
      
 27063 
     | 
    
         
            +
                                requestId: import("zod").ZodString;
         
     | 
| 
      
 27064 
     | 
    
         
            +
                            }, "strip", import("zod").ZodTypeAny, {
         
     | 
| 
      
 27065 
     | 
    
         
            +
                                requestId: string;
         
     | 
| 
      
 27066 
     | 
    
         
            +
                            }, {
         
     | 
| 
      
 27067 
     | 
    
         
            +
                                requestId: string;
         
     | 
| 
      
 27068 
     | 
    
         
            +
                            }>;
         
     | 
| 
      
 27069 
     | 
    
         
            +
                        };
         
     | 
| 
      
 27070 
     | 
    
         
            +
                        path: "ms/dashboard/export-user-check-in-logs-by-user-id";
         
     | 
| 
      
 27071 
     | 
    
         
            +
                    };
         
     | 
| 
       26911 
27072 
     | 
    
         
             
                };
         
     | 
| 
       26912 
27073 
     | 
    
         
             
                permission: {
         
     | 
| 
       26913 
27074 
     | 
    
         
             
                    getPermissions: {
         
     |