@wix/auto_sdk_staff-time-clock_timecards 0.0.0-stage → 1.0.0

package/build/cjs/index.d.ts

@@ -0,0 +1,243 @@
+import { HttpClient, NonNullablePaths, MaybeContext, BuildRESTFunction } from '@wix/sdk-types';
+import { GenerateStaffTokenResponse, GenerateStaffTokenApplicationErrors, GetTimeClockDetailsResponse, GetTimeClockDetailsApplicationErrors, KioskClockInTimecardOptions, ClockInTimecardResponse, KioskClockInTimecardApplicationErrors, KioskClockOutTimecardOptions, ClockOutTimecardResponse, KioskClockOutTimecardApplicationErrors, KioskStartTimecardTaskOptions, StartTimecardTaskResponse, KioskStartTimecardTaskApplicationErrors, KioskEndTimecardTaskOptions, EndTimecardTaskResponse, KioskEndTimecardTaskApplicationErrors, ClockInTimecardOptions, ClockOutTimecardOptions, StartTimecardTaskOptions, EndTimecardTaskOptions, GetOpenTimecardOptions, GetOpenTimecardResponse, Timecard, CreateTimecardOptions, UpdateTimecard, UpdateTimecardOptions, DeleteTimecardOptions, GetTimecardOptions, ListAggregatedTimecardsOptions, ListAggregatedTimecardsResponse, TimecardQuery, QueryTimecardsOptions, typedQueryTimecards, TimecardsQueryBuilder } from './index.typings.js';
+export { AccountInfo, ActionEvent, AggregatedTimecard, ClockInTimecardRequest, ClockOutTimecardRequest, ClockPunch, ClockSource, ClockSourceWithLiterals, CloseTimecardRequest, CloseTimecardResponse, CommonQueryWithEntityContext, CompletePinSetupRequest, CompletePinSetupResponse, CreateTimecardRequest, CreateTimecardResponse, CursorPaging, CursorPagingMetadata, CursorQuery, CursorQueryPagingMethodOneOf, Cursors, DeleteTimecardRequest, DeleteTimecardResponse, DomainEvent, DomainEventBodyOneOf, Empty, EndTimecardTaskRequest, EntityCreatedEvent, EntityDeletedEvent, EntityUpdatedEvent, GenerateStaffTokenRequest, GetOpenTimecardRequest, GetTimeClockDetailsRequest, GetTimecardRequest, GetTimecardResponse, IdentificationData, IdentificationDataIdOneOf, ListAggregatedTimecardsRequest, LocationWorkedTime, MessageEnvelope, QueryTimecardsRequest, QueryTimecardsResponse, RestoreInfo, SendPinSetupLinkRequest, SendPinSetupLinkResponse, SortOrder, SortOrderWithLiterals, Sorting, StartTimecardTaskRequest, Task, TaskAssignment, TimecardQuerySpec, TimecardsQueryResult, TimecardsTotals, UpdateTimecardRequest, UpdateTimecardResponse, ValidatePinSetupLinkRequest, ValidatePinSetupLinkResponse, WebhookIdentityType, WebhookIdentityTypeWithLiterals, WorkedTime, ZonedDate, utils } from './index.typings.js';
+
+declare function generateStaffToken$1(httpClient: HttpClient): GenerateStaffTokenSignature;
+interface GenerateStaffTokenSignature {
+    /**
+     * Exchanges a staff member's PIN hash for a short-lived StaffToken.
+     *
+     * Call this with the device's Kiosk Token as a bearer credential. The site and
+     * location are taken from that token.
+     *
+     * A PIN that matches no staff member and a staff member who has no PIN return the
+     * same error, with no detail distinguishing them.
+     * @param - Hash of the PIN the staff member entered, as uppercase hex, computed as
+     * `SHA-256("Pin(symbols=[1, 2, 3, 4])|<metaSiteId>")` over the entered digits and
+     * the site ID from the device's pairing context.
+     */
+    (pin: string): Promise<NonNullablePaths<GenerateStaffTokenResponse, `staffToken`, 0> & {
+        __applicationErrorsType?: GenerateStaffTokenApplicationErrors;
+    }>;
+}
+declare function getTimeClockDetails$1(httpClient: HttpClient): GetTimeClockDetailsSignature;
+interface GetTimeClockDetailsSignature {
+    /**
+     * Retrieves the signed-in staff member's open timecard and the site's task catalog.
+     *
+     * Call this with the staff member's StaffToken as a bearer credential. The staff
+     * member is taken from that token.
+     */
+    (): Promise<NonNullablePaths<GetTimeClockDetailsResponse, `openTimecard.staffMemberId` | `openTimecard.clockIn.source` | `openTimecard.taskAssignments` | `openTimecard.taskAssignments.${number}.taskId` | `openTimecard.taskAssignments.${number}.label` | `openTimecard.taskAssignments.${number}.paid` | `tasks` | `tasks.${number}.label` | `tasks.${number}.paid`, 3> & {
+        __applicationErrorsType?: GetTimeClockDetailsApplicationErrors;
+    }>;
+}
+declare function kioskClockInTimecard$1(httpClient: HttpClient): KioskClockInTimecardSignature;
+interface KioskClockInTimecardSignature {
+    /**
+     * Opens a timecard for the signed-in staff member (clock-in).
+     *
+     * Call this with the staff member's StaffToken as a bearer credential. Idempotent:
+     * if the staff member already has an open timecard, it is returned with
+     * `wasAlreadyOpen` set instead of opening a second one.
+     */
+    (options?: KioskClockInTimecardOptions): Promise<NonNullablePaths<ClockInTimecardResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid` | `wasAlreadyOpen`, 3> & {
+        __applicationErrorsType?: KioskClockInTimecardApplicationErrors;
+    }>;
+}
+declare function kioskClockOutTimecard$1(httpClient: HttpClient): KioskClockOutTimecardSignature;
+interface KioskClockOutTimecardSignature {
+    /**
+     * Closes the signed-in staff member's open timecard (clock-out). Any still-running
+     * task segment is closed at the same time.
+     *
+     * Call this with the staff member's StaffToken as a bearer credential.
+     */
+    (options?: KioskClockOutTimecardOptions): Promise<NonNullablePaths<ClockOutTimecardResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid`, 3> & {
+        __applicationErrorsType?: KioskClockOutTimecardApplicationErrors;
+    }>;
+}
+declare function kioskStartTimecardTask$1(httpClient: HttpClient): KioskStartTimecardTaskSignature;
+interface KioskStartTimecardTaskSignature {
+    /**
+     * Starts a task on the signed-in staff member's open timecard. If another task is
+     * already running it is closed first (a task switch).
+     *
+     * Call this with the staff member's StaffToken as a bearer credential.
+     */
+    (options?: KioskStartTimecardTaskOptions): Promise<NonNullablePaths<StartTimecardTaskResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid`, 3> & {
+        __applicationErrorsType?: KioskStartTimecardTaskApplicationErrors;
+    }>;
+}
+declare function kioskEndTimecardTask$1(httpClient: HttpClient): KioskEndTimecardTaskSignature;
+interface KioskEndTimecardTaskSignature {
+    /**
+     * Ends the running task on the signed-in staff member's open timecard, returning it
+     * to untasked working time.
+     *
+     * Call this with the staff member's StaffToken as a bearer credential.
+     */
+    (options?: KioskEndTimecardTaskOptions): Promise<NonNullablePaths<EndTimecardTaskResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid`, 3> & {
+        __applicationErrorsType?: KioskEndTimecardTaskApplicationErrors;
+    }>;
+}
+declare function clockInTimecard$1(httpClient: HttpClient): ClockInTimecardSignature;
+interface ClockInTimecardSignature {
+    /**
+     * Opens a timecard for a staff member (clock-in).
+     *
+     * If the staff member already has an open timecard, from any source, no second
+     * timecard is opened. The existing timecard is returned with `wasAlreadyOpen` set
+     * to `true`.
+     *
+     * The call fails if the new timecard would overlap one the staff member already
+     * has. For example, a timecard with a clock-out time in the future still covers
+     * the moment of the clock-in.
+     *
+     * A staff member who clocks themselves in needs self clock-in to be enabled in the
+     * site's time clock settings. Clocking in on behalf of a staff member, for example
+     * from a kiosk, doesn't depend on that setting.
+     */
+    (options?: ClockInTimecardOptions): Promise<NonNullablePaths<ClockInTimecardResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid` | `wasAlreadyOpen`, 3>>;
+}
+declare function clockOutTimecard$1(httpClient: HttpClient): ClockOutTimecardSignature;
+interface ClockOutTimecardSignature {
+    /**
+     * Closes the staff member's open timecard (clock-out).
+     *
+     * A task that is still running is closed at the same time. The call fails if the
+     * staff member has no open timecard, so a second call right after a clock-out
+     * fails.
+     */
+    (options?: ClockOutTimecardOptions): Promise<NonNullablePaths<ClockOutTimecardResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid`, 3>>;
+}
+declare function startTimecardTask$1(httpClient: HttpClient): StartTimecardTaskSignature;
+interface StartTimecardTaskSignature {
+    /**
+     * Starts a task on the staff member's open timecard.
+     *
+     * If another task is already running, it is closed first, so switching tasks takes
+     * a single call. The task's label and whether it's paid are copied from the site's
+     * task catalog when the task starts. Later changes to the catalog don't affect it.
+     */
+    (options?: StartTimecardTaskOptions): Promise<NonNullablePaths<StartTimecardTaskResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid`, 3>>;
+}
+declare function endTimecardTask$1(httpClient: HttpClient): EndTimecardTaskSignature;
+interface EndTimecardTaskSignature {
+    /**
+     * Ends the running task on the staff member's open timecard, returning it to
+     * untasked working time.
+     *
+     * The call fails if no task is running.
+     */
+    (options?: EndTimecardTaskOptions): Promise<NonNullablePaths<EndTimecardTaskResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid`, 3>>;
+}
+declare function getOpenTimecard$1(httpClient: HttpClient): GetOpenTimecardSignature;
+interface GetOpenTimecardSignature {
+    /**
+     * Retrieves the staff member's open timecard.
+     *
+     * If the staff member is clocked out, no timecard is returned. Use this to show
+     * whether a staff member is clocked in, working on a task, or clocked out.
+     */
+    (options?: GetOpenTimecardOptions): Promise<NonNullablePaths<GetOpenTimecardResponse, `timecard.staffMemberId` | `timecard.clockIn.source` | `timecard.taskAssignments` | `timecard.taskAssignments.${number}.taskId` | `timecard.taskAssignments.${number}.label` | `timecard.taskAssignments.${number}.paid`, 3>>;
+}
+declare function createTimecard$1(httpClient: HttpClient): CreateTimecardSignature;
+interface CreateTimecardSignature {
+    /**
+     * Creates a timecard directly, for example for a manual entry.
+     *
+     * Provide a complete record: either a closed timecard with a clock-in and a
+     * clock-out, or an open timecard with only a clock-in. The `source` of the punches
+     * is set to `MANUAL`. You can provide a `reason`, which is recorded in the
+     * timecard's audit trail. `locationId` is optional.
+     * @param - Timecard to create.
+     * @returns Created timecard.
+     */
+    (timecard: NonNullablePaths<Timecard, `clockIn` | `clockIn.date.localDate` | `clockIn.date.timeZone` | `staffMemberId`, 2>, options?: CreateTimecardOptions): Promise<NonNullablePaths<Timecard, `staffMemberId` | `clockIn.source` | `taskAssignments` | `taskAssignments.${number}.taskId` | `taskAssignments.${number}.label` | `taskAssignments.${number}.paid`, 2>>;
+}
+declare function updateTimecard$1(httpClient: HttpClient): UpdateTimecardSignature;
+interface UpdateTimecardSignature {
+    /**
+     * Updates a timecard, for example to correct a clock-in or clock-out time.
+     *
+     * Each time the timecard is updated, `revision` increments by 1. The current
+     * `revision` must be passed when updating the timecard. This ensures you're working
+     * with the latest timecard and prevents unintended overwrites.
+     *
+     * Only the fields in `fieldMask` are updated. You can provide a `reason`, which is
+     * recorded in the timecard's audit trail.
+     * @param - Timecard ID.
+     * @returns Updated timecard.
+     */
+    (_id: string, timecard: NonNullablePaths<UpdateTimecard, `revision`, 0>, options?: UpdateTimecardOptions): Promise<NonNullablePaths<Timecard, `staffMemberId` | `clockIn.source` | `taskAssignments` | `taskAssignments.${number}.taskId` | `taskAssignments.${number}.label` | `taskAssignments.${number}.paid`, 2>>;
+}
+declare function deleteTimecard$1(httpClient: HttpClient): DeleteTimecardSignature;
+interface DeleteTimecardSignature {
+    /**
+     * Deletes a timecard.
+     *
+     * You can provide a `reason`, which is recorded in the timecard's audit trail.
+     * @param - ID of the timecard to delete.
+     */
+    (timecardId: string, options?: DeleteTimecardOptions): Promise<void>;
+}
+declare function getTimecard$1(httpClient: HttpClient): GetTimecardSignature;
+interface GetTimecardSignature {
+    /**
+     * Retrieves a timecard by ID.
+     * @param - ID of the timecard to retrieve.
+     * @returns Retrieved timecard.
+     */
+    (timecardId: string, options?: GetTimecardOptions): Promise<NonNullablePaths<Timecard, `staffMemberId` | `clockIn.source` | `taskAssignments` | `taskAssignments.${number}.taskId` | `taskAssignments.${number}.label` | `taskAssignments.${number}.paid`, 2>>;
+}
+declare function listAggregatedTimecards$1(httpClient: HttpClient): ListAggregatedTimecardsSignature;
+interface ListAggregatedTimecardsSignature {
+    /**
+     * Retrieves the hours each staff member worked over a date range.
+     *
+     * The response has one row per staff member with paid, unpaid, and total hours, a
+     * breakdown by location, and totals across all rows.
+     *
+     * A timecard counts toward the day its clock-in falls on, whenever it was clocked
+     * out. A shift that crosses midnight is reported whole against the day it started
+     * and doesn't appear in the next day's report. You can therefore add up reports
+     * over consecutive ranges without counting an overnight shift twice.
+     *
+     * `locationIds` limits which locations the hours are summed over, and a staff
+     * member with no timecards in those locations isn't listed. `staffMemberIds` limits
+     * which rows are returned and doesn't change the hours per location. Open timecards
+     * aren't included in the hours. They're returned as `openTimecardId`.
+     *
+     * The range can span up to 92 days. Currently, all rows are returned in a single
+     * page, and `cursorPaging` is ignored.
+     * @param - First day of the reporting range, inclusive. Interpreted in `timeZone`, so the
+     * range starts at the beginning of this day. A timecard is included when its
+     * clock-in falls within the range, whenever it was clocked out.
+     */
+    (fromLocalDate: string, options?: NonNullablePaths<ListAggregatedTimecardsOptions, `timeZone` | `toLocalDate`, 0>): Promise<NonNullablePaths<ListAggregatedTimecardsResponse, `aggregatedTimecards` | `aggregatedTimecards.${number}.staffMemberId` | `totals.staffCount` | `totals.openTimecardCount`, 2>>;
+}
+
+declare function customQueryTimecards(httpClient: HttpClient): {
+    (query: TimecardQuery, options?: QueryTimecardsOptions): ReturnType<typeof typedQueryTimecards>;
+    (options?: QueryTimecardsOptions): TimecardsQueryBuilder;
+};
+declare const generateStaffToken: MaybeContext<BuildRESTFunction<typeof generateStaffToken$1> & typeof generateStaffToken$1>;
+declare const getTimeClockDetails: MaybeContext<BuildRESTFunction<typeof getTimeClockDetails$1> & typeof getTimeClockDetails$1>;
+declare const kioskClockInTimecard: MaybeContext<BuildRESTFunction<typeof kioskClockInTimecard$1> & typeof kioskClockInTimecard$1>;
+declare const kioskClockOutTimecard: MaybeContext<BuildRESTFunction<typeof kioskClockOutTimecard$1> & typeof kioskClockOutTimecard$1>;
+declare const kioskStartTimecardTask: MaybeContext<BuildRESTFunction<typeof kioskStartTimecardTask$1> & typeof kioskStartTimecardTask$1>;
+declare const kioskEndTimecardTask: MaybeContext<BuildRESTFunction<typeof kioskEndTimecardTask$1> & typeof kioskEndTimecardTask$1>;
+declare const clockInTimecard: MaybeContext<BuildRESTFunction<typeof clockInTimecard$1> & typeof clockInTimecard$1>;
+declare const clockOutTimecard: MaybeContext<BuildRESTFunction<typeof clockOutTimecard$1> & typeof clockOutTimecard$1>;
+declare const startTimecardTask: MaybeContext<BuildRESTFunction<typeof startTimecardTask$1> & typeof startTimecardTask$1>;
+declare const endTimecardTask: MaybeContext<BuildRESTFunction<typeof endTimecardTask$1> & typeof endTimecardTask$1>;
+declare const getOpenTimecard: MaybeContext<BuildRESTFunction<typeof getOpenTimecard$1> & typeof getOpenTimecard$1>;
+declare const createTimecard: MaybeContext<BuildRESTFunction<typeof createTimecard$1> & typeof createTimecard$1>;
+declare const updateTimecard: MaybeContext<BuildRESTFunction<typeof updateTimecard$1> & typeof updateTimecard$1>;
+declare const deleteTimecard: MaybeContext<BuildRESTFunction<typeof deleteTimecard$1> & typeof deleteTimecard$1>;
+declare const getTimecard: MaybeContext<BuildRESTFunction<typeof getTimecard$1> & typeof getTimecard$1>;
+declare const listAggregatedTimecards: MaybeContext<BuildRESTFunction<typeof listAggregatedTimecards$1> & typeof listAggregatedTimecards$1>;
+declare const queryTimecards: MaybeContext<BuildRESTFunction<typeof customQueryTimecards> & typeof customQueryTimecards>;
+
+export { ClockInTimecardOptions, ClockInTimecardResponse, ClockOutTimecardOptions, ClockOutTimecardResponse, CreateTimecardOptions, DeleteTimecardOptions, EndTimecardTaskOptions, EndTimecardTaskResponse, GenerateStaffTokenApplicationErrors, GenerateStaffTokenResponse, GetOpenTimecardOptions, GetOpenTimecardResponse, GetTimeClockDetailsApplicationErrors, GetTimeClockDetailsResponse, GetTimecardOptions, KioskClockInTimecardApplicationErrors, KioskClockInTimecardOptions, KioskClockOutTimecardApplicationErrors, KioskClockOutTimecardOptions, KioskEndTimecardTaskApplicationErrors, KioskEndTimecardTaskOptions, KioskStartTimecardTaskApplicationErrors, KioskStartTimecardTaskOptions, ListAggregatedTimecardsOptions, ListAggregatedTimecardsResponse, QueryTimecardsOptions, StartTimecardTaskOptions, StartTimecardTaskResponse, Timecard, TimecardQuery, TimecardsQueryBuilder, UpdateTimecard, UpdateTimecardOptions, clockInTimecard, clockOutTimecard, createTimecard, deleteTimecard, endTimecardTask, generateStaffToken, getOpenTimecard, getTimeClockDetails, getTimecard, kioskClockInTimecard, kioskClockOutTimecard, kioskEndTimecardTask, kioskStartTimecardTask, listAggregatedTimecards, queryTimecards, startTimecardTask, updateTimecard };