@alexisapp/leave-core 0.0.1-beta.1

package/dist/queries/index.d.ts

@@ -0,0 +1,489 @@
+import { L as ListLeaveQueryVariables, a as ListLeaveQuery, E as Exact, I as InputMaybe, b as LeaveFilterInput, S as Scalars, c as LeaveSortInput, d as ListLeaveVisibleQuery, G as GetLeaveQuery, e as GetEmployeeVacationBalanceQuery, f as ListEmployeeVacationBalanceQueryVariables, g as ListEmployeeVacationBalanceQuery, h as EmployeeVacationBalanceFilterInput, i as GetLeaveUsageQueryVariables, j as GetLeaveUsageQuery, k as GetLeaveOverlapsQuery, l as GetLeaveApproversQueryVariables, m as GetLeaveApproversQuery, n as ListLeaveSelfCertifiedQueryVariables, o as ListLeaveSelfCertifiedQuery, p as Exact$1, q as InputMaybe$1, r as LeaveSelfCertifiedFiltersInput, s as Scalars$1, t as ListLeaveSelfCertifiedVisibleQueryVariables, u as ListLeaveSelfCertifiedVisibleQuery, v as GetLeaveSelfCertifiedQuery, w as ListLeaveChangesQueryVariables, x as ListLeaveChangesQuery, y as LeaveChangeFiltersInput, z as LeaveChangeSortInput, A as GetLeaveChangeQuery, B as GetTimeBankBalanceQuery, C as ListLeavePoliciesQueryVariables, D as ListLeavePoliciesQuery, F as LeavePolicyFilterInput, H as LeavePolicySortInput, J as GetLeavePolicyQuery, K as ListSelfCertifiedPoliciesQueryVariables, M as ListSelfCertifiedPoliciesQuery, N as LeaveSelfCertifiedPolicyFiltersInput, O as GetLeaveSelfCertifiedPolicyQuery, P as ListLeaveTypesQueryVariables, Q as ListLeaveTypesQuery, R as FilterGroupInput, T as SortByInput, U as GetEmployeeLeaveTypesQuery, V as GetEmployeeQuery, W as GetEmploymentQuery, X as ListEmploymentsQueryVariables, Y as ListEmploymentsQuery, Z as EmploymentFilter, _ as EmploymentSortInput, $ as GetWorkWeekQueryVariables, a0 as GetWorkWeekQuery, a1 as ListCompanyHolidaysQueryVariables, a2 as ListCompanyHolidaysQuery, a3 as CompanyHolidayFilterInput, a4 as CompanyHolidaySortInput, a5 as ListPublicHolidaysQueryVariables, a6 as ListPublicHolidaysQuery, a7 as PublicHolidayFilterInput, a8 as PublicHolidaySortInput, a9 as ListRestrictedDatesQueryVariables, aa as ListRestrictedDatesQuery, ab as RestrictedDateFilterInput, ac as RestrictedDateSortInput, ad as GetTimeOffSettingsQuery, ae as GetTimeOffSettingsByKeyQuery, af as MeQuery } from '../graphql-BI4OTV8N.js';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import '@graphql-typed-document-node/core';
+
+declare const leaveQueries: {
+    all: readonly ["leave"];
+    lists: () => readonly ["leave", "list"];
+    list: (variables?: ListLeaveQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListLeaveQuery, Error, ListLeaveQuery, readonly ["leave", "list", Exact<{
+        filters?: InputMaybe<LeaveFilterInput>;
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        skip?: InputMaybe<Scalars["Int"]["input"]>;
+        sort?: InputMaybe<LeaveSortInput>;
+    }> | undefined]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListLeaveQuery, readonly ["leave", "list", Exact<{
+            filters?: InputMaybe<LeaveFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<LeaveSortInput>;
+        }> | undefined], never>;
+    } & {
+        queryKey: readonly ["leave", "list", Exact<{
+            filters?: InputMaybe<LeaveFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<LeaveSortInput>;
+        }> | undefined] & {
+            [dataTagSymbol]: ListLeaveQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    listVisible: () => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListLeaveVisibleQuery, Error, ListLeaveVisibleQuery, readonly ["leave", "list", "visible"]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListLeaveVisibleQuery, readonly ["leave", "list", "visible"], never>;
+    } & {
+        queryKey: readonly ["leave", "list", "visible"] & {
+            [dataTagSymbol]: ListLeaveVisibleQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    details: () => readonly ["leave", "detail"];
+    detail: (id: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetLeaveQuery, Error, GetLeaveQuery, readonly ["leave", "detail", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetLeaveQuery, readonly ["leave", "detail", string], never>;
+    } & {
+        queryKey: readonly ["leave", "detail", string] & {
+            [dataTagSymbol]: GetLeaveQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    balances: () => readonly ["leave", "balance"];
+    balance: (employeeId: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetEmployeeVacationBalanceQuery, Error, GetEmployeeVacationBalanceQuery, readonly ["leave", "balance", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetEmployeeVacationBalanceQuery, readonly ["leave", "balance", string], never>;
+    } & {
+        queryKey: readonly ["leave", "balance", string] & {
+            [dataTagSymbol]: GetEmployeeVacationBalanceQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    balanceList: (variables?: ListEmployeeVacationBalanceQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListEmployeeVacationBalanceQuery, Error, ListEmployeeVacationBalanceQuery, readonly ["leave", "balance", "list", Exact<{
+        filters?: InputMaybe<EmployeeVacationBalanceFilterInput>;
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        skip?: InputMaybe<Scalars["Int"]["input"]>;
+    }> | undefined]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListEmployeeVacationBalanceQuery, readonly ["leave", "balance", "list", Exact<{
+            filters?: InputMaybe<EmployeeVacationBalanceFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+        }> | undefined], never>;
+    } & {
+        queryKey: readonly ["leave", "balance", "list", Exact<{
+            filters?: InputMaybe<EmployeeVacationBalanceFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+        }> | undefined] & {
+            [dataTagSymbol]: ListEmployeeVacationBalanceQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    usages: () => readonly ["leave", "usage"];
+    usage: (variables: GetLeaveUsageQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetLeaveUsageQuery, Error, GetLeaveUsageQuery, readonly ["leave", "usage", Exact<{
+        employeeId: Scalars["ID"]["input"];
+        typeIds: Array<InputMaybe<Scalars["ID"]["input"]>> | InputMaybe<Scalars["ID"]["input"]>;
+        from: Scalars["DateTime"]["input"];
+        to: Scalars["DateTime"]["input"];
+        childId?: InputMaybe<Scalars["ID"]["input"]>;
+    }>]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetLeaveUsageQuery, readonly ["leave", "usage", Exact<{
+            employeeId: Scalars["ID"]["input"];
+            typeIds: Array<InputMaybe<Scalars["ID"]["input"]>> | InputMaybe<Scalars["ID"]["input"]>;
+            from: Scalars["DateTime"]["input"];
+            to: Scalars["DateTime"]["input"];
+            childId?: InputMaybe<Scalars["ID"]["input"]>;
+        }>], never>;
+    } & {
+        queryKey: readonly ["leave", "usage", Exact<{
+            employeeId: Scalars["ID"]["input"];
+            typeIds: Array<InputMaybe<Scalars["ID"]["input"]>> | InputMaybe<Scalars["ID"]["input"]>;
+            from: Scalars["DateTime"]["input"];
+            to: Scalars["DateTime"]["input"];
+            childId?: InputMaybe<Scalars["ID"]["input"]>;
+        }>] & {
+            [dataTagSymbol]: GetLeaveUsageQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    overlaps: () => readonly ["leave", "overlap"];
+    overlap: (leaveId: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetLeaveOverlapsQuery, Error, GetLeaveOverlapsQuery, readonly ["leave", "overlap", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetLeaveOverlapsQuery, readonly ["leave", "overlap", string], never>;
+    } & {
+        queryKey: readonly ["leave", "overlap", string] & {
+            [dataTagSymbol]: GetLeaveOverlapsQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    approvers: () => readonly ["leave", "approver"];
+    approver: (variables: GetLeaveApproversQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetLeaveApproversQuery, Error, GetLeaveApproversQuery, readonly ["leave", "approver", Exact<{
+        companyId: Scalars["ObjectId"]["input"];
+        employeeId: Scalars["ObjectId"]["input"];
+        leaveTypeId: Scalars["ObjectId"]["input"];
+    }>]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetLeaveApproversQuery, readonly ["leave", "approver", Exact<{
+            companyId: Scalars["ObjectId"]["input"];
+            employeeId: Scalars["ObjectId"]["input"];
+            leaveTypeId: Scalars["ObjectId"]["input"];
+        }>], never>;
+    } & {
+        queryKey: readonly ["leave", "approver", Exact<{
+            companyId: Scalars["ObjectId"]["input"];
+            employeeId: Scalars["ObjectId"]["input"];
+            leaveTypeId: Scalars["ObjectId"]["input"];
+        }>] & {
+            [dataTagSymbol]: GetLeaveApproversQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    selfCertified: () => readonly ["leave", "self-certified"];
+    selfCertifiedList: (variables?: ListLeaveSelfCertifiedQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListLeaveSelfCertifiedQuery, Error, ListLeaveSelfCertifiedQuery, readonly ["leave", "self-certified", "list", Exact$1<{
+        filters?: InputMaybe$1<LeaveSelfCertifiedFiltersInput>;
+        limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+    }> | undefined]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListLeaveSelfCertifiedQuery, readonly ["leave", "self-certified", "list", Exact$1<{
+            filters?: InputMaybe$1<LeaveSelfCertifiedFiltersInput>;
+            limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        }> | undefined], never>;
+    } & {
+        queryKey: readonly ["leave", "self-certified", "list", Exact$1<{
+            filters?: InputMaybe$1<LeaveSelfCertifiedFiltersInput>;
+            limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        }> | undefined] & {
+            [dataTagSymbol]: ListLeaveSelfCertifiedQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    selfCertifiedListVisible: (variables?: ListLeaveSelfCertifiedVisibleQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListLeaveSelfCertifiedVisibleQuery, Error, ListLeaveSelfCertifiedVisibleQuery, readonly ["leave", "self-certified", "listVisible", Exact$1<{
+        filters?: InputMaybe$1<LeaveSelfCertifiedFiltersInput>;
+        limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+    }> | undefined]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListLeaveSelfCertifiedVisibleQuery, readonly ["leave", "self-certified", "listVisible", Exact$1<{
+            filters?: InputMaybe$1<LeaveSelfCertifiedFiltersInput>;
+            limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        }> | undefined], never>;
+    } & {
+        queryKey: readonly ["leave", "self-certified", "listVisible", Exact$1<{
+            filters?: InputMaybe$1<LeaveSelfCertifiedFiltersInput>;
+            limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        }> | undefined] & {
+            [dataTagSymbol]: ListLeaveSelfCertifiedVisibleQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    selfCertifiedDetail: (id: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetLeaveSelfCertifiedQuery, Error, GetLeaveSelfCertifiedQuery, readonly ["leave", "self-certified", "detail", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetLeaveSelfCertifiedQuery, readonly ["leave", "self-certified", "detail", string], never>;
+    } & {
+        queryKey: readonly ["leave", "self-certified", "detail", string] & {
+            [dataTagSymbol]: GetLeaveSelfCertifiedQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    approvals: () => readonly ["leave", "approval"];
+    approvalQueue: (variables?: ListLeaveChangesQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListLeaveChangesQuery, Error, ListLeaveChangesQuery, readonly ["leave", "approval", "list", Exact$1<{
+        filters?: InputMaybe$1<LeaveChangeFiltersInput>;
+        limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        sort?: InputMaybe$1<LeaveChangeSortInput>;
+    }> | undefined]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListLeaveChangesQuery, readonly ["leave", "approval", "list", Exact$1<{
+            filters?: InputMaybe$1<LeaveChangeFiltersInput>;
+            limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            sort?: InputMaybe$1<LeaveChangeSortInput>;
+        }> | undefined], never>;
+    } & {
+        queryKey: readonly ["leave", "approval", "list", Exact$1<{
+            filters?: InputMaybe$1<LeaveChangeFiltersInput>;
+            limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            sort?: InputMaybe$1<LeaveChangeSortInput>;
+        }> | undefined] & {
+            [dataTagSymbol]: ListLeaveChangesQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    approvalDetail: (id: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetLeaveChangeQuery, Error, GetLeaveChangeQuery, readonly ["leave", "approval", "detail", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetLeaveChangeQuery, readonly ["leave", "approval", "detail", string], never>;
+    } & {
+        queryKey: readonly ["leave", "approval", "detail", string] & {
+            [dataTagSymbol]: GetLeaveChangeQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    timeBanks: () => readonly ["leave", "time-bank"];
+    timeBank: (employeeId: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetTimeBankBalanceQuery, Error, GetTimeBankBalanceQuery, readonly ["leave", "time-bank", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetTimeBankBalanceQuery, readonly ["leave", "time-bank", string], never>;
+    } & {
+        queryKey: readonly ["leave", "time-bank", string] & {
+            [dataTagSymbol]: GetTimeBankBalanceQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+};
+
+declare const policyQueries: {
+    all: readonly ["policy"];
+    lists: () => readonly ["policy", "list"];
+    list: (variables?: ListLeavePoliciesQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListLeavePoliciesQuery, Error, ListLeavePoliciesQuery, readonly ["policy", "list", Exact<{
+        filters?: InputMaybe<LeavePolicyFilterInput>;
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        skip?: InputMaybe<Scalars["Int"]["input"]>;
+        sort?: InputMaybe<LeavePolicySortInput>;
+    }> | undefined]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListLeavePoliciesQuery, readonly ["policy", "list", Exact<{
+            filters?: InputMaybe<LeavePolicyFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<LeavePolicySortInput>;
+        }> | undefined], never>;
+    } & {
+        queryKey: readonly ["policy", "list", Exact<{
+            filters?: InputMaybe<LeavePolicyFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<LeavePolicySortInput>;
+        }> | undefined] & {
+            [dataTagSymbol]: ListLeavePoliciesQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    details: () => readonly ["policy", "detail"];
+    detail: (id: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetLeavePolicyQuery, Error, GetLeavePolicyQuery, readonly ["policy", "detail", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetLeavePolicyQuery, readonly ["policy", "detail", string], never>;
+    } & {
+        queryKey: readonly ["policy", "detail", string] & {
+            [dataTagSymbol]: GetLeavePolicyQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    selfCertified: () => readonly ["policy", "self-certified"];
+    selfCertifiedList: (variables?: ListSelfCertifiedPoliciesQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListSelfCertifiedPoliciesQuery, Error, ListSelfCertifiedPoliciesQuery, readonly ["policy", "self-certified", "list", Exact$1<{
+        filters?: InputMaybe$1<LeaveSelfCertifiedPolicyFiltersInput>;
+        limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+    }> | undefined]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListSelfCertifiedPoliciesQuery, readonly ["policy", "self-certified", "list", Exact$1<{
+            filters?: InputMaybe$1<LeaveSelfCertifiedPolicyFiltersInput>;
+            limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        }> | undefined], never>;
+    } & {
+        queryKey: readonly ["policy", "self-certified", "list", Exact$1<{
+            filters?: InputMaybe$1<LeaveSelfCertifiedPolicyFiltersInput>;
+            limit?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+            offset?: InputMaybe$1<Scalars$1["Float"]["input"]>;
+        }> | undefined] & {
+            [dataTagSymbol]: ListSelfCertifiedPoliciesQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    selfCertifiedDetail: (id: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetLeaveSelfCertifiedPolicyQuery, Error, GetLeaveSelfCertifiedPolicyQuery, readonly ["policy", "self-certified", "detail", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetLeaveSelfCertifiedPolicyQuery, readonly ["policy", "self-certified", "detail", string], never>;
+    } & {
+        queryKey: readonly ["policy", "self-certified", "detail", string] & {
+            [dataTagSymbol]: GetLeaveSelfCertifiedPolicyQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    leaveTypes: () => readonly ["policy", "leave-type"];
+    leaveTypeList: (variables: ListLeaveTypesQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListLeaveTypesQuery, Error, ListLeaveTypesQuery, readonly ["policy", "leave-type", "list", Exact<{
+        filters: FilterGroupInput;
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        skip?: InputMaybe<Scalars["Int"]["input"]>;
+        sortBy?: InputMaybe<Array<InputMaybe<SortByInput>> | InputMaybe<SortByInput>>;
+    }>]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListLeaveTypesQuery, readonly ["policy", "leave-type", "list", Exact<{
+            filters: FilterGroupInput;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sortBy?: InputMaybe<Array<InputMaybe<SortByInput>> | InputMaybe<SortByInput>>;
+        }>], never>;
+    } & {
+        queryKey: readonly ["policy", "leave-type", "list", Exact<{
+            filters: FilterGroupInput;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sortBy?: InputMaybe<Array<InputMaybe<SortByInput>> | InputMaybe<SortByInput>>;
+        }>] & {
+            [dataTagSymbol]: ListLeaveTypesQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    employeeLeaveTypes: (employeeId: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetEmployeeLeaveTypesQuery, Error, GetEmployeeLeaveTypesQuery, readonly ["policy", "leave-type", "employee", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetEmployeeLeaveTypesQuery, readonly ["policy", "leave-type", "employee", string], never>;
+    } & {
+        queryKey: readonly ["policy", "leave-type", "employee", string] & {
+            [dataTagSymbol]: GetEmployeeLeaveTypesQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+};
+
+declare const employeeQueries: {
+    all: readonly ["employee"];
+    details: () => readonly ["employee", "detail"];
+    detail: (id: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetEmployeeQuery, Error, GetEmployeeQuery, readonly ["employee", "detail", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetEmployeeQuery, readonly ["employee", "detail", string], never>;
+    } & {
+        queryKey: readonly ["employee", "detail", string] & {
+            [dataTagSymbol]: GetEmployeeQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    employments: () => readonly ["employee", "employment"];
+    employment: (id: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetEmploymentQuery, Error, GetEmploymentQuery, readonly ["employee", "employment", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetEmploymentQuery, readonly ["employee", "employment", string], never>;
+    } & {
+        queryKey: readonly ["employee", "employment", string] & {
+            [dataTagSymbol]: GetEmploymentQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    employmentList: (variables: ListEmploymentsQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListEmploymentsQuery, Error, ListEmploymentsQuery, readonly ["employee", "employment", "list", Exact<{
+        filters?: InputMaybe<EmploymentFilter>;
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        skip?: InputMaybe<Scalars["Int"]["input"]>;
+        sort?: InputMaybe<EmploymentSortInput>;
+    }>]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListEmploymentsQuery, readonly ["employee", "employment", "list", Exact<{
+            filters?: InputMaybe<EmploymentFilter>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<EmploymentSortInput>;
+        }>], never>;
+    } & {
+        queryKey: readonly ["employee", "employment", "list", Exact<{
+            filters?: InputMaybe<EmploymentFilter>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<EmploymentSortInput>;
+        }>] & {
+            [dataTagSymbol]: ListEmploymentsQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    workWeeks: () => readonly ["employee", "work-week"];
+    workWeek: (variables: GetWorkWeekQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetWorkWeekQuery, Error, GetWorkWeekQuery, readonly ["employee", "work-week", Exact<{
+        id: Scalars["ID"]["input"];
+    }>]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetWorkWeekQuery, readonly ["employee", "work-week", Exact<{
+            id: Scalars["ID"]["input"];
+        }>], never>;
+    } & {
+        queryKey: readonly ["employee", "work-week", Exact<{
+            id: Scalars["ID"]["input"];
+        }>] & {
+            [dataTagSymbol]: GetWorkWeekQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    holidays: () => readonly ["employee", "holiday"];
+    companyHolidays: (variables: ListCompanyHolidaysQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListCompanyHolidaysQuery, Error, ListCompanyHolidaysQuery, readonly ["employee", "holiday", "company", Exact<{
+        filters?: InputMaybe<CompanyHolidayFilterInput>;
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        skip?: InputMaybe<Scalars["Int"]["input"]>;
+        sort?: InputMaybe<CompanyHolidaySortInput>;
+    }>]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListCompanyHolidaysQuery, readonly ["employee", "holiday", "company", Exact<{
+            filters?: InputMaybe<CompanyHolidayFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<CompanyHolidaySortInput>;
+        }>], never>;
+    } & {
+        queryKey: readonly ["employee", "holiday", "company", Exact<{
+            filters?: InputMaybe<CompanyHolidayFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<CompanyHolidaySortInput>;
+        }>] & {
+            [dataTagSymbol]: ListCompanyHolidaysQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    publicHolidays: (variables: ListPublicHolidaysQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListPublicHolidaysQuery, Error, ListPublicHolidaysQuery, readonly ["employee", "holiday", "public", Exact<{
+        filters?: InputMaybe<PublicHolidayFilterInput>;
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        skip?: InputMaybe<Scalars["Int"]["input"]>;
+        sort?: InputMaybe<PublicHolidaySortInput>;
+    }>]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListPublicHolidaysQuery, readonly ["employee", "holiday", "public", Exact<{
+            filters?: InputMaybe<PublicHolidayFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<PublicHolidaySortInput>;
+        }>], never>;
+    } & {
+        queryKey: readonly ["employee", "holiday", "public", Exact<{
+            filters?: InputMaybe<PublicHolidayFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<PublicHolidaySortInput>;
+        }>] & {
+            [dataTagSymbol]: ListPublicHolidaysQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    restrictedDates: () => readonly ["employee", "restricted-date"];
+    restrictedDateList: (variables: ListRestrictedDatesQueryVariables) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListRestrictedDatesQuery, Error, ListRestrictedDatesQuery, readonly ["employee", "restricted-date", Exact<{
+        filters?: InputMaybe<RestrictedDateFilterInput>;
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        skip?: InputMaybe<Scalars["Int"]["input"]>;
+        sort?: InputMaybe<RestrictedDateSortInput>;
+    }>]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<ListRestrictedDatesQuery, readonly ["employee", "restricted-date", Exact<{
+            filters?: InputMaybe<RestrictedDateFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<RestrictedDateSortInput>;
+        }>], never>;
+    } & {
+        queryKey: readonly ["employee", "restricted-date", Exact<{
+            filters?: InputMaybe<RestrictedDateFilterInput>;
+            limit?: InputMaybe<Scalars["Int"]["input"]>;
+            skip?: InputMaybe<Scalars["Int"]["input"]>;
+            sort?: InputMaybe<RestrictedDateSortInput>;
+        }>] & {
+            [dataTagSymbol]: ListRestrictedDatesQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+};
+
+declare const settingsQueries: {
+    all: readonly ["settings"];
+    details: () => readonly ["settings", "detail"];
+    detail: (id: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetTimeOffSettingsQuery, Error, GetTimeOffSettingsQuery, readonly ["settings", "detail", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetTimeOffSettingsQuery, readonly ["settings", "detail", string], never>;
+    } & {
+        queryKey: readonly ["settings", "detail", string] & {
+            [dataTagSymbol]: GetTimeOffSettingsQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    keys: () => readonly ["settings", "key"];
+    byKey: (key: string) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetTimeOffSettingsByKeyQuery, Error, GetTimeOffSettingsByKeyQuery, readonly ["settings", "key", string]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<GetTimeOffSettingsByKeyQuery, readonly ["settings", "key", string], never>;
+    } & {
+        queryKey: readonly ["settings", "key", string] & {
+            [dataTagSymbol]: GetTimeOffSettingsByKeyQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+};
+
+declare const userQueries: {
+    all: readonly ["user"];
+    me: () => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<MeQuery, Error, MeQuery, readonly ["user", "me"]>, "queryFn"> & {
+        queryFn?: _tanstack_react_query.QueryFunction<MeQuery, readonly ["user", "me"], never>;
+    } & {
+        queryKey: readonly ["user", "me"] & {
+            [dataTagSymbol]: MeQuery;
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+};
+
+export { employeeQueries, leaveQueries, policyQueries, settingsQueries, userQueries };

package/dist/queries/index.mjs

@@ -0,0 +1,15 @@
+import {
+  employeeQueries,
+  leaveQueries,
+  policyQueries,
+  settingsQueries,
+  userQueries
+} from "../chunk-P5WZALLT.mjs";
+import "../chunk-TUQKZ7GW.mjs";
+export {
+  employeeQueries,
+  leaveQueries,
+  policyQueries,
+  settingsQueries,
+  userQueries
+};

package/dist/stores/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/utils/index.d.ts

@@ -0,0 +1,40 @@
+export { D as DisplayStatus, L as LeaveChangeType, r as resolveDisplayStatus } from '../leaveStatusUtils-C26heVdh.js';
+
+/**
+ * Formats a date range for display on leave cards.
+ *
+ * - Single day, current year: "20 Mar"
+ * - Single day, other year: "20 Mar 2025"
+ * - Multi-day, same year, current year: "14 Apr – 18 Apr"
+ * - Cross-year: "23 Dec 2025 – 2 Jan 2026"
+ * - Null end date (open-ended): "1 Apr – ongoing"
+ */
+declare function formatDateRange(localStartDate: string, localEndDate: string | null | undefined, ongoingLabel?: string): string;
+
+interface SplittableLeaveItem {
+    localStartDate: string;
+    localEndDate: string | null;
+}
+/**
+ * Splits leave items into "upcoming" and "history" sections.
+ *
+ * - Upcoming: leaves where `localEndDate >= today` or `localEndDate` is null (open-ended).
+ *   Sorted ascending by `localStartDate`.
+ * - History: leaves where `localEndDate < today`.
+ *   Sorted descending by `localStartDate`.
+ *
+ * @param today - YYYY-MM-DD string in local timezone. Injected for testability.
+ */
+declare function splitLeaveSections<T extends SplittableLeaveItem>(items: readonly T[], today: string): {
+    upcoming: T[];
+    history: T[];
+};
+/**
+ * Returns today's date as a YYYY-MM-DD string in the local timezone.
+ */
+declare function getLocalToday(): string;
+
+/** Equivalent of `.filter(Boolean)`, but type-safe. */
+declare const isDefined: <T>(value: T | null | undefined) => value is NonNullable<T>;
+
+export { type SplittableLeaveItem, formatDateRange, getLocalToday, isDefined, splitLeaveSections };

package/dist/utils/index.mjs

@@ -0,0 +1,53 @@
+import {
+  getLocalToday,
+  isDefined,
+  resolveDisplayStatus,
+  splitLeaveSections
+} from "../chunk-R7NHFDIU.mjs";
+
+// src/utils/formatDateRangeUtils.ts
+var shortDateFormatter = new Intl.DateTimeFormat("en-GB", {
+  day: "numeric",
+  month: "short"
+});
+var shortDateWithYearFormatter = new Intl.DateTimeFormat("en-GB", {
+  day: "numeric",
+  month: "short",
+  year: "numeric"
+});
+var EN_DASH = "\u2013";
+function parseLocalDate(dateStr) {
+  const [year, month, day] = dateStr.split("-").map(Number);
+  return new Date(year, month - 1, day);
+}
+function getCurrentYear() {
+  return (/* @__PURE__ */ new Date()).getFullYear();
+}
+function formatDateRange(localStartDate, localEndDate, ongoingLabel = "ongoing") {
+  const start = parseLocalDate(localStartDate);
+  const startYear = start.getFullYear();
+  const currentYear = getCurrentYear();
+  if (localEndDate == null) {
+    const startStr = startYear !== currentYear ? shortDateWithYearFormatter.format(start) : shortDateFormatter.format(start);
+    return `${startStr} ${EN_DASH} ${ongoingLabel}`;
+  }
+  const end = parseLocalDate(localEndDate);
+  const endYear = end.getFullYear();
+  if (localStartDate === localEndDate) {
+    return startYear !== currentYear ? shortDateWithYearFormatter.format(start) : shortDateFormatter.format(start);
+  }
+  if (startYear !== endYear) {
+    return `${shortDateWithYearFormatter.format(start)} ${EN_DASH} ${shortDateWithYearFormatter.format(end)}`;
+  }
+  if (startYear !== currentYear) {
+    return `${shortDateWithYearFormatter.format(start)} ${EN_DASH} ${shortDateWithYearFormatter.format(end)}`;
+  }
+  return `${shortDateFormatter.format(start)} ${EN_DASH} ${shortDateFormatter.format(end)}`;
+}
+export {
+  formatDateRange,
+  getLocalToday,
+  isDefined,
+  resolveDisplayStatus,
+  splitLeaveSections
+};