@gusto/embedded-react-sdk 0.55.5 → 0.55.7

package/dist/src/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/payrollEditEmployeeHelpers.d.ts

@@ -0,0 +1,155 @@
+import { PayrollEmployeeCompensationsType } from '@gusto/embedded-api/models/components/payrollemployeecompensationstype';
+import { EarningTypeList } from '@gusto/embedded-api/models/components/earningtypelist';
+import { PayrollUpdateEmployeeCompensations } from '@gusto/embedded-api/models/components/payrollupdate';
+import { RFCDate } from '@gusto/embedded-api/types/rfcdate';
+import { PayrollEditEmployeeFormData, PayrollEditEmployeeFormOutputs } from './payrollEditEmployeeSchema';
+import { PayrollCategory } from '../../../payrollTypes';
+/** One fixed-compensation line off the prepared compensation. */
+type FixedCompensationEntry = NonNullable<PayrollEmployeeCompensationsType['fixedCompensations']>[number];
+/**
+ * Normalized form of a workweek: the API exposes
+ * `{ startDate?: RFCDate; endDate?: RFCDate }`, but the hook keys week-maps by
+ * `YYYY-MM-DD` strings and builds breakdowns from them, so both boundaries are
+ * required strings here. Surfaced on the hook's `data.workweeks` so the UI can
+ * label each per-workweek column without re-parsing the raw API workweeks.
+ *
+ * @internal
+ */
+export interface NormalizedWorkweek {
+    startDate: string;
+    endDate: string;
+}
+/**
+ * Normalizes the prepared payroll's top-level `workweeks` into
+ * {@link NormalizedWorkweek} boundary strings, falling back to a single
+ * pay-period-spanning workweek when the API returns no workweek boundaries.
+ *
+ * @param workweeks - The prepared payroll's top-level `workweeks` (RFCDate boundaries), possibly `null`.
+ * @param payPeriod - The prepared payroll's `payPeriod`, used as the single-workweek fallback.
+ * @returns One entry per workweek; a single entry spanning the pay period when none are supplied.
+ * @throws SDKInternalError when neither workweeks nor a pay period are present (a malformed prepared payroll).
+ * @internal
+ */
+export declare function normalizeWorkweeks(workweeks: Array<{
+    startDate?: RFCDate;
+    endDate?: RFCDate;
+}> | null | undefined, payPeriod: {
+    startDate?: string;
+    endDate?: string;
+} | undefined): NormalizedWorkweek[];
+/**
+ * Collects the names of earning types included in the regular-rate-of-pay
+ * overtime calculation. These earnings render in the workweek-breakdown
+ * additional-earnings section; all others fall into the flat `other` section.
+ *
+ * @param earningTypeList - The company's default and custom earning types.
+ * @returns A set of earning-type names with `includedInOvertimePay` set.
+ * @internal
+ */
+export declare function collectOvertimeEarningNames(earningTypeList: EarningTypeList | undefined): Set<string>;
+/**
+ * Merges the employee's existing fixed compensations with a blank placeholder for
+ * every payroll fixed-compensation type they don't yet have, mirroring the stable editor
+ * (`getAdditionalEarningsCompensations`). This is what lets the editor surface an
+ * empty input for Bonus, Commission, etc. even when the prepared payroll carries
+ * no fixed compensations. Placeholders attach to the primary job and carry no
+ * amount (blank), so an untouched earning submits as zero without altering pay.
+ *
+ * @remarks
+ * Owners (FLSA status `Owner`) never receive placeholders. Earning types that are
+ * handled elsewhere or never shown as additional earnings
+ * ({@link EXCLUDED_ADDITIONAL_EARNINGS}) and inactive types are skipped. The
+ * result is sorted alphabetically by name. The regular-rate-of-pay split between
+ * additional earnings and `other` happens downstream via `overtimeEarningNames`;
+ * this helper only decides which earning lines exist.
+ *
+ * @param existingFixedCompensations - The prepared compensation's fixed compensations.
+ * @param fixedCompensationTypes - The prepared payroll's `fixedCompensationTypes` (the same source the stable editor uses).
+ * @param primaryJobUuid - The employee's primary job UUID; placeholders attach here.
+ * @param flsaStatus - The employee's FLSA status; owners get no placeholders.
+ * @returns The merged, filtered, alphabetically sorted fixed-compensation lines.
+ * @internal
+ */
+export declare function resolveEditableFixedCompensations(existingFixedCompensations: FixedCompensationEntry[] | undefined, fixedCompensationTypes: Array<{
+    name?: string | null;
+}> | undefined, primaryJobUuid: string | undefined, flsaStatus: string | undefined): FixedCompensationEntry[];
+/**
+ * Whether the employee's prepared compensation already carries non-zero
+ * Overtime or Double-overtime hours.
+ *
+ * @remarks
+ * Used to default the single `withOvertime` flag: an employee who already
+ * has real overtime hours starts with the workweek split shown rather than
+ * requiring an extra click to see data that's already there.
+ *
+ * @param hourlyCompensations - The prepared compensation's hourly lines.
+ * @returns `true` when any Overtime or Double-overtime line has hours greater than zero.
+ * @internal
+ */
+export declare function hasExistingOvertimeHours(hourlyCompensations: PayrollEmployeeCompensationsType['hourlyCompensations'] | undefined): boolean;
+/**
+ * Whether any of the employee's hourly-compensation lines already carries a
+ * real, per-workweek `breakdowns` array that exactly tiles the current pay
+ * period's workweeks.
+ *
+ * @remarks
+ * Used alongside {@link hasExistingOvertimeHours} to default the single
+ * `withOvertime` flag: an employee whose hours are already broken down by
+ * workweek (e.g. a previous edit entered real per-week values) starts with the
+ * workweek split shown, seeded from those breakdowns rather than from a blank
+ * or first-cell-only guess. See {@link buildWeekMap}, which applies the same
+ * per-line check to decide each line's population mode.
+ *
+ * @param hourlyCompensations - The prepared compensation's hourly lines.
+ * @param workweeks - Normalized workweeks for the pay period.
+ * @returns `true` when at least one hourly line's breakdowns cover every workweek.
+ * @internal
+ */
+export declare function hasBreakdownsMatchingWorkweeks(hourlyCompensations: PayrollEmployeeCompensationsType['hourlyCompensations'] | undefined, workweeks: NormalizedWorkweek[]): boolean;
+/**
+ * Derives the form's default values from the employee's prepared compensation.
+ *
+ * @remarks
+ * Hourly and additional earnings are expanded into per-workweek maps via
+ * {@link buildWeekMap}: collapsed to the total when not split, seeded from real
+ * breakdowns or first-cell-only otherwise. Time off, final payout,
+ * reimbursements, and payment method are read straight off the compensation.
+ *
+ * @param employeeCompensation - The employee's prepared compensation, if loaded.
+ * @param workweeks - Normalized workweeks for the pay period.
+ * @param withOvertime - The single, form-wide overtime-mode flag (see {@link hasExistingOvertimeHours}, {@link hasBreakdownsMatchingWorkweeks}, `actions.addOvertime`). Gates splitting alongside `isOvertimeEligible`.
+ * @returns Default {@link PayrollEditEmployeeFormData} for `useForm`.
+ * @internal
+ */
+export declare function derivePayrollEditEmployeeDefaults(employeeCompensation: PayrollEmployeeCompensationsType | undefined, workweeks: NormalizedWorkweek[], hasDirectDepositSetup: boolean, overtimeEarningNames: Set<string>, isOvertimeEligible: boolean, withOvertime: boolean, fixedCompensations?: FixedCompensationEntry[]): PayrollEditEmployeeFormData;
+/**
+ * Builds the `PayrollUpdate` employee-compensation payload from form values.
+ *
+ * @remarks
+ * When the pay period spans a single workweek (or the employee isn't split by
+ * workweek), totals are sent without `breakdowns`. When split, each hourly and
+ * additional-earning line is decided independently — per line, not per job
+ * (the API models breakdowns on each compensation line, not as a per-job
+ * all-or-nothing unit):
+ *
+ * - A fully-filled line (every workweek cell has a value) sends `breakdowns`
+ *   tiling every workweek exactly, with the total equal to the sum of the
+ *   per-week values.
+ * - An entirely blank line sends nothing for it — no `breakdowns`, no
+ *   fabricated `0`, no fabricated total — leaving it as the flat, untouched
+ *   value it already was.
+ * - A partial line (some but not all cells filled) can never reach this
+ *   function: {@link createPayrollEditEmployeeSchema}'s per-row check blocks
+ *   submit until every cell in a touched row is filled.
+ *
+ * @param formData - Current parsed form values.
+ * @param employeeCompensation - The prepared compensation, for identifying metadata (`version`, `employeeUuid`).
+ * @param workweeks - Normalized workweeks for the pay period.
+ * @param payrollCategory - The payroll category, gating itemized vs. off-cycle reimbursements.
+ * @param isOvertimeEligible - Whether the employee is overtime-eligible (nonexempt family).
+ * @param withOvertime - The single, form-wide overtime-mode flag. Gates splitting alongside `isOvertimeEligible` and `workweeks.length > 1`; when `false`, every line submits its flat (collapsed) value regardless of eligibility.
+ * @returns The employee-compensation entry for the `PayrollUpdate` request body.
+ * @internal
+ */
+export declare function buildPayrollUpdateEmployeeCompensation(formData: PayrollEditEmployeeFormOutputs, employeeCompensation: PayrollEmployeeCompensationsType | undefined, workweeks: NormalizedWorkweek[], payrollCategory: PayrollCategory, isOvertimeEligible: boolean, withOvertime: boolean): PayrollUpdateEmployeeCompensations;
+export {};

package/dist/src/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/payrollEditEmployeeSchema.d.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+/**
+ * Payment-method option values, in display order. The hook publishes these on
+ * `fieldsMetadata.paymentMethod` via `withOptions`; the UI supplies the
+ * translated labels through `getOptionLabel`.
+ *
+ * @internal
+ */
+export declare const PAYMENT_METHOD_VALUES: readonly ["Direct Deposit", "Check"];
+/** @internal */
+export declare const PAYMENT_METHOD_OPTIONS: {
+    value: "Check" | "Direct Deposit";
+    label: "Check" | "Direct Deposit";
+}[];
+/**
+ * Validation error codes produced by the payroll edit-employee schema.
+ *
+ * @public
+ */
+export declare const PayrollEditEmployeeErrorCodes: {
+    readonly NEGATIVE_AMOUNT: "NEGATIVE_AMOUNT";
+    readonly REIMBURSEMENT_AMOUNT: "REIMBURSEMENT_AMOUNT";
+    readonly REQUIRED_WORKWEEK: "REQUIRED_WORKWEEK";
+};
+/**
+ * Union of validation error codes emitted by the payroll edit-employee schema.
+ *
+ * @public
+ */
+export type PayrollEditEmployeeErrorCode = (typeof PayrollEditEmployeeErrorCodes)[keyof typeof PayrollEditEmployeeErrorCodes];
+/**
+ * The single reimbursement validation schema: the "add reimbursement" draft row.
+ * Amount must be a number greater than zero, matching the legacy editor's
+ * inline validation. The hook validates the draft against this before committing
+ * it to the presentational `reimbursements` list.
+ *
+ * @internal
+ */
+export declare const reimbursementDraftSchema: z.ZodObject<{
+    description: z.ZodString;
+    amount: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Builds the Zod schema for the payroll edit-employee form.
+ *
+ * @remarks
+ * Overtime-affecting values are keyed by workweek internally: hours and
+ * additional earnings are job-then-name-then-workweekStart records, so the
+ * single-workweek (or not-yet-split) case is just the degenerate one-key form
+ * of the multi-workweek shape. Non-overtime earnings (other) are flat
+ * job-then-name-to-amount records with no per-workweek breakdown, since they do
+ * not feed the blended rate. Time off and final payout are keyed by
+ * compensation name. This keeps one schema and one submit path.
+ *
+ * A `superRefine` enforces per-row completeness on `hours` and
+ * `additionalEarnings`: once any workweek cell in a job+name row is filled, every
+ * other cell in that row must be filled too, surfaced per empty cell as
+ * {@link PayrollEditEmployeeErrorCodes.REQUIRED_WORKWEEK}. A row with nothing
+ * filled is left alone (still submittable as untouched). This needs no
+ * workweek/split context passed in — it's purely structural on whatever keys a
+ * row happens to have, which is why a collapsed row (always exactly one key)
+ * can never trigger it.
+ *
+ * @returns The Zod schema validating {@link PayrollEditEmployeeFormData}.
+ * @internal
+ */
+export declare function createPayrollEditEmployeeSchema(): z.ZodObject<{
+    hours: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    additionalEarnings: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    other: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeOff: z.ZodRecord<z.ZodString, z.ZodString>;
+    finalPayout: z.ZodRecord<z.ZodString, z.ZodString>;
+    reimbursements: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodString;
+        amount: z.ZodString;
+        recurring: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    reimbursementDraft: z.ZodObject<{
+        description: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$strip>;
+    paymentMethod: z.ZodOptional<z.ZodEnum<{
+        readonly DirectDeposit: "Direct Deposit";
+        readonly Check: "Check";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Shape of the values managed by the payroll edit-employee form.
+ *
+ * @public
+ */
+export type PayrollEditEmployeeFormData = z.infer<ReturnType<typeof createPayrollEditEmployeeSchema>>;
+/**
+ * Validated values produced by the payroll edit-employee form on submit.
+ *
+ * @internal
+ */
+export type PayrollEditEmployeeFormOutputs = PayrollEditEmployeeFormData;
+/**
+ * A single reimbursement row in {@link PayrollEditEmployeeFormData}.
+ *
+ * @public
+ */
+export type ReimbursementFormEntry = PayrollEditEmployeeFormData['reimbursements'][number];

package/dist/src/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/usePayrollEditEmployeeForm.d.ts

@@ -0,0 +1,165 @@
+import { UseFormProps } from 'react-hook-form';
+import { Employee } from '@gusto/embedded-api/models/components/employee';
+import { PayrollEmployeeCompensationsType } from '@gusto/embedded-api/models/components/payrollemployeecompensationstype';
+import { PayrollPrepared } from '@gusto/embedded-api/models/components/payrollshow';
+import { PayScheduleShow } from '@gusto/embedded-api/models/components/payscheduleshow';
+import { PayrollEditEmployeeFormData } from './payrollEditEmployeeSchema';
+import { NormalizedWorkweek } from './payrollEditEmployeeHelpers';
+import { PayrollEditEmployeeErrorMessages, PayrollEditEmployeeFields, ReimbursementRow } from './fields';
+import { BaseFormHookReady, FieldMetadata, FieldMetadataWithOptions, HookLoadingResult, HookSubmitResult } from '../../../../../partner-hook-utils/types';
+/**
+ * Options accepted by {@link usePayrollEditEmployeeForm}.
+ *
+ * @public
+ */
+export interface UsePayrollEditEmployeeFormProps {
+    /** The associated employee identifier. */
+    employeeId: string;
+    /** The associated company identifier. */
+    companyId: string;
+    /** The associated payroll identifier. */
+    payrollId: string;
+    /**
+     * Whether to expose reimbursement controls (`form.Fields.reimbursements`,
+     * `actions.addReimbursement`/`removeReimbursement`, `form.reimbursements`).
+     * Defaults to `true`. Controls are omitted for off-cycle payrolls regardless,
+     * since those write reimbursements via the legacy fixed-compensation path.
+     */
+    withReimbursements?: boolean;
+    /** When validation runs. Passed through to react-hook-form. Defaults to `'onSubmit'`. */
+    validationMode?: UseFormProps['mode'];
+    /** Auto-focus the first invalid field on submit. Defaults to `true`. Set to `false` when composing with other forms. */
+    shouldFocusError?: boolean;
+    /**
+     * Display copy for each validation error code, baked into every bound field so
+     * it resolves and renders its own message. Supply it once, keyed by
+     * {@link PayrollEditEmployeeErrorCodes}; a missing code falls back to the raw
+     * code. Omit it to render raw codes.
+     */
+    errorMessages?: PayrollEditEmployeeErrorMessages;
+}
+/**
+ * Field metadata for {@link usePayrollEditEmployeeForm}, keyed by full form path.
+ *
+ * @remarks
+ * Keys are minted from the prepared payroll's compensations at runtime
+ * (`hours.${jobUuid}.${name}.${workweekStart}` and similar), so neither the key
+ * set nor which entries carry options is known ahead of time.
+ *
+ * @public
+ */
+export type PayrollEditEmployeeFieldsMetadata = Record<string, FieldMetadata | FieldMetadataWithOptions>;
+/**
+ * Ready-state return value of {@link usePayrollEditEmployeeForm} — the
+ * `isLoading: false` branch of {@link UsePayrollEditEmployeeFormResult}.
+ *
+ * @public
+ */
+export interface UsePayrollEditEmployeeFormReady extends BaseFormHookReady<PayrollEditEmployeeFieldsMetadata, PayrollEditEmployeeFormData, PayrollEditEmployeeFields> {
+    /** Loaded entities backing the editor. */
+    data: {
+        /** The employee being edited. */
+        employee: Employee;
+        /** The employee's prepared compensation for this payroll, if present. */
+        employeeCompensation?: PayrollEmployeeCompensationsType;
+        /** The prepared payroll (server-calculated totals and workweeks). */
+        preparedPayroll: PayrollPrepared;
+        /** The pay schedule for the payroll, if loaded. */
+        paySchedule?: PayScheduleShow;
+        /** Whether the pay period spans more than one workweek. Raw workweeks are on `preparedPayroll.workweeks`. */
+        isMultipleWorkweeks: boolean;
+        /**
+         * The pay period's normalized workweeks (`{ startDate, endDate }` strings),
+         * in order — one entry, spanning the pay period, when it's a single
+         * workweek. The per-workweek split fields are keyed by start date only, so
+         * this is the source for each column's date range.
+         */
+        workweeks: NormalizedWorkweek[];
+        /** Whether the employee is overtime-eligible (nonexempt family). Drives whether hours split by workweek. */
+        isOvertimeEligible: boolean;
+        /**
+         * The single, form-wide overtime-mode flag. `false` renders one flat
+         * column per line with Overtime/Double-overtime rows hidden; `true`
+         * splits hours and overtime-affecting earnings into per-workweek columns
+         * (for overtime-eligible employees on a multi-workweek payroll) and
+         * un-hides those rows. Starts `true` when the employee already has real
+         * overtime hours or matching per-workweek breakdowns (see
+         * `hasExistingOvertimeHours`, `hasBreakdownsMatchingWorkweeks`), or after
+         * `actions.addOvertime` is called; otherwise starts `false`.
+         */
+        withOvertime: boolean;
+        /** Whether the employee has a direct-deposit bank account set up. */
+        hasDirectDepositSetup: boolean;
+        /**
+         * Committed reimbursement rows to render in a table, present only when
+         * reimbursement controls are exposed. Seeded from the employee's existing
+         * reimbursements and appended to as drafts are saved. Remove a row via
+         * `actions.removeReimbursement(row.index)`.
+         */
+        reimbursements?: ReimbursementRow[];
+    };
+    /** Submission status. `mode` is always `'update'` since the payroll already exists. */
+    status: {
+        isPending: boolean;
+        mode: 'update';
+    };
+    /** Form actions. */
+    actions: {
+        /** Validates and submits the form, resolving to the updated prepared payroll on success or `undefined` when validation blocked the submit. */
+        onSubmit: () => Promise<HookSubmitResult<PayrollPrepared> | undefined>;
+        /**
+         * Sets `data.withOvertime` to `true`, switching the whole form to the
+         * workweek split: un-hides Overtime/Double-overtime rows and splits hours
+         * and overtime-affecting earnings into per-workweek columns. Populates
+         * only the first workweek cell of each line with that line's current
+         * total, leaving every other cell blank — no auto distribution — so the
+         * per-row validation then requires the user to fill in the rest. One
+         * affordance for the whole employee, not one per job. One-directional —
+         * there's no corresponding "remove overtime" action.
+         */
+        addOvertime: () => void;
+        /** Reveals the draft reimbursement row. Present only when reimbursement controls are exposed. */
+        beginAddReimbursement?: () => void;
+        /** Validates the draft and commits it to the reimbursement list, or flags the draft amount if invalid. Present only when reimbursement controls are exposed. */
+        saveReimbursement?: () => void;
+        /** Discards the draft reimbursement row. Present only when reimbursement controls are exposed. */
+        cancelReimbursement?: () => void;
+        /** Removes the committed reimbursement row at `index` (zeroing existing rows so the update clears them). Present only when reimbursement controls are exposed. */
+        removeReimbursement?: (index: number) => void;
+    };
+    /** Form internals plus the reimbursement draft state. */
+    form: BaseFormHookReady<PayrollEditEmployeeFieldsMetadata, PayrollEditEmployeeFormData, PayrollEditEmployeeFields>['form'] & {
+        /** Draft reimbursement state, present only when reimbursement controls are exposed. */
+        reimbursementDraft?: {
+            isAdding: boolean;
+        };
+    };
+}
+/**
+ * Discriminated union returned by {@link usePayrollEditEmployeeForm}. Loading
+ * branch carries only `errorHandling`; ready branch carries form data, fields,
+ * status, and actions.
+ *
+ * @public
+ */
+export type UsePayrollEditEmployeeFormResult = HookLoadingResult | UsePayrollEditEmployeeFormReady;
+/**
+ * Headless form hook for editing a single employee's compensation within a
+ * payroll run, built for regular-rate-of-pay (RRoP) support.
+ *
+ * @remarks
+ * Prepares the payroll for the target employee, then exposes a workweek-keyed
+ * form whose submit builds a `PayrollUpdate`. Single-workweek pay periods send
+ * totals without `breakdowns`; multi-workweek pay periods send `breakdowns` per
+ * line once that line's every workweek cell is filled. Overtime-eligible
+ * (nonexempt) employees split hours and overtime-affecting earnings per
+ * workweek while the single `data.withOvertime` flag is on (see
+ * `actions.addOvertime`); everyone else, and every line while `withOvertime` is
+ * off, edits flat totals.
+ *
+ * @param props - Hook options.
+ * @returns A loading result while data is fetching, or a ready result with data,
+ * fields, status, actions, and error handling.
+ * @public
+ */
+export declare function usePayrollEditEmployeeForm({ employeeId, companyId, payrollId, withReimbursements, validationMode, shouldFocusError, errorMessages, }: UsePayrollEditEmployeeFormProps): UsePayrollEditEmployeeFormResult;

package/dist/src/components/Payroll/PayrollOverview/PayrollOverviewPresentation.d.ts

@@ -0,0 +1,38 @@
+import { PayrollShow } from '@gusto/embedded-api/models/components/payrollshow';
+import { CompanyBankAccount } from '@gusto/embedded-api/models/components/companybankaccount';
+import { PayrollSubmissionBlockerType } from '@gusto/embedded-api/models/components/payrollsubmissionblockertype';
+import { PaymentSpeed } from '@gusto/embedded-api/models/components/paymentconfigs';
+import { PayrollFlowAlert } from '../PayrollFlow/PayrollFlowComponents';
+import { PayrollOverviewStatus } from './PayrollOverviewTypes';
+import { PaginationControlProps } from '../../Common/PaginationControl/PaginationControlTypes';
+interface PayrollOverviewProps {
+    payrollData: PayrollShow;
+    employeeFlsaStatusByUuid?: Record<string, string | undefined>;
+    bankAccount?: CompanyBankAccount;
+    taxes: Record<string, {
+        employee: number;
+        employer: number;
+    }>;
+    status?: PayrollOverviewStatus;
+    isProcessed: boolean;
+    canCancel?: boolean;
+    canEdit?: boolean;
+    alerts?: PayrollFlowAlert[];
+    submissionBlockers?: PayrollSubmissionBlockerType[];
+    selectedUnblockOptions?: Record<string, string>;
+    wireInConfirmationRequest?: React.ReactNode;
+    printChecksBanner?: React.ReactNode;
+    pagination?: PaginationControlProps;
+    onEdit: () => void;
+    onSubmit: () => void;
+    onCancel: () => void;
+    onPayrollReceipt: () => void;
+    onPaystubDownload: (employeeId: string) => void;
+    onUnblockOptionChange?: (blockerType: string, value: string) => void;
+    withReimbursements?: boolean;
+    paymentSpeed?: PaymentSpeed;
+    downloadingEmployeeIds?: ReadonlySet<string>;
+}
+/** @internal */
+export declare const PayrollOverviewPresentation: ({ onEdit, onSubmit, onCancel, onPayrollReceipt, onPaystubDownload, payrollData, employeeFlsaStatusByUuid, bankAccount, taxes, status, isProcessed, canCancel, canEdit, alerts, submissionBlockers, selectedUnblockOptions, onUnblockOptionChange, wireInConfirmationRequest, printChecksBanner, withReimbursements, paymentSpeed, pagination, downloadingEmployeeIds, }: PayrollOverviewProps) => import("react").JSX.Element;
+export {};

package/dist/src/components/Payroll/PayrollOverview/useSubmissionPoll.d.ts

@@ -0,0 +1,39 @@
+import { PayrollsGetQueryData, PayrollsGetQueryError } from '@gusto/embedded-api/react-query/payrollsGet';
+import { QueryObserverResult } from '@tanstack/react-query';
+/** @internal */
+export type PayrollShow = NonNullable<PayrollsGetQueryData['payrollShow']>;
+/**
+ * Per-run state for the submission poll. `baseline` is only known when the run starts from a
+ * click on Submit, where the pre-submit render already has data to snapshot. A run started
+ * without one (e.g. to guard the initial read on mount) relies on `sawSubmitting` alone.
+ *
+ * @internal
+ */
+export interface SubmissionPollRun {
+    baseline: {
+        processed: boolean;
+        status: string | undefined;
+    } | null;
+    sawSubmitting: boolean;
+}
+/** @internal */
+export interface UseSubmissionPollOptions {
+    /**
+     * The render-driving payroll query's own `refetch`, reused so the poll's reads land on the
+     * same query the component observes rather than racing a second, independently-built one.
+     */
+    refetch: () => Promise<QueryObserverResult<PayrollsGetQueryData, PayrollsGetQueryError>>;
+    onProcessed: (payroll: PayrollShow | undefined) => void;
+    onProcessingFailed: (payroll: PayrollShow | undefined) => void;
+}
+/** @internal */
+export interface SubmissionPoll {
+    start: (run: SubmissionPollRun) => void;
+    isPolling: boolean;
+}
+/**
+ * Polls a payroll until its submission reaches a terminal state, via {@link usePollingTask}.
+ *
+ * @internal
+ */
+export declare function useSubmissionPoll({ refetch, onProcessed, onProcessingFailed, }: UseSubmissionPollOptions): SubmissionPoll;

package/dist/src/components/Payroll/PrintChecks/PrintChecksForm/useGenerationPoll.d.ts

@@ -0,0 +1,17 @@
+/** @internal */
+export interface UseGenerationPollOptions {
+    onSucceeded: (url: string | null) => void;
+    onFailed: () => void;
+}
+/** @internal */
+export interface GenerationPoll {
+    /** Starts polling the generated-document status for `requestUuid`. */
+    start: (requestUuid: string) => void;
+}
+/**
+ * Polls a generated print-checks document until it reaches a terminal state, via
+ * {@link usePollingTask}.
+ *
+ * @internal
+ */
+export declare function useGenerationPoll({ onSucceeded, onFailed, }: UseGenerationPollOptions): GenerationPoll;

package/dist/src/components/Payroll/UNSTABLE_PayrollEditEmployee/UNSTABLE_PayrollEditEmployee.d.ts

@@ -0,0 +1,20 @@
+import { PayrollEditEmployeeProps } from '../PayrollEditEmployee/PayrollEditEmployee';
+/**
+ * In-development regular-rate-of-pay rebuild of {@link PayrollEditEmployee}.
+ *
+ * @remarks
+ * Gated behind the `payrollRegularRateOfPay` unstable feature flag and not part of the public
+ * SDK surface. `PayrollEditEmployee` renders this in place of the stable editor when the flag is
+ * enabled. Consumes {@link usePayrollEditEmployeeForm} and renders the header, the hours /
+ * additional-earnings / time-off / other / payment-method sections, and the
+ * `Cancel`/`Save` controls, performing a real payroll update on save. For an overtime-eligible
+ * employee on a multi-workweek payroll, Overtime/Double-overtime rows start hidden behind a single,
+ * employee-level "Add overtime" control (`form.data.withOvertime` / `form.actions.addOvertime`)
+ * unless the employee already has real overtime hours or matching per-workweek breakdowns; adding
+ * overtime also switches hours and overtime-affecting earnings to per-workweek columns and surfaces
+ * the per-row "fill in every workweek" validation. `Cancel` and `Save` emit the same events as the
+ * stable component so the surrounding flow behaves identically.
+ *
+ * @internal
+ */
+export declare function UNSTABLE_PayrollEditEmployee({ FallbackComponent, LoaderComponent, ...props }: PayrollEditEmployeeProps): import("react").JSX.Element;