@gusto/embedded-react-sdk 0.57.2 → 0.58.0

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

@@ -19,7 +19,9 @@ export interface PayrollExecutionFlowProps {
     companyId: string;
     /**
      * The identifier of the payroll to execute. The payroll must already exist (e.g. created by a
-     * prior creation step or by the standard `PayrollFlow` selection).
+     * prior creation step or by the standard `PayrollFlow` selection). For a transition payroll,
+     * render {@link TransitionConfiguration} first and pass the same ID here after it emits
+     * `transition/configured`.
      */
     payrollId: string;
     /** Event handler that receives the `RUN_PAYROLL_*` events emitted during the flow. */
@@ -59,10 +61,10 @@ export interface PayrollExecutionInternalFlowProps extends PayrollExecutionFlowP
  *
  * @remarks
  * This is the inner flow that powers the back half of `Payroll.PayrollFlow`, and it is also reused
- * by the off-cycle, dismissal, and transition flows after they have created their respective
- * payrolls. Render it directly when you have built your own payroll-creation step and want to hand
- * the user off to the standard execution experience without re-implementing it. The flow ships
- * with breadcrumb navigation and the standard wire-confirmation UX.
+ * by the off-cycle and dismissal flows after they have created their respective payrolls. Render it
+ * directly when you have built your own payroll-creation step and want to hand the user off to the
+ * standard execution experience without re-implementing it. The flow ships with breadcrumb
+ * navigation and the standard wire-confirmation UX.
  *
  * @events
  * | Event | Description | Data |
@@ -118,7 +120,7 @@ export declare function PayrollExecutionFlow(props: PayrollExecutionFlowProps):
 /**
  * Flow-internal entry point for {@link PayrollExecutionFlow} that additionally accepts
  * flow-injected `prefixBreadcrumbs`. Partners use {@link PayrollExecutionFlow}; our own parent
- * flows (off-cycle, dismissal, transition, and `PayrollFlow`) render this directly to prepend
+ * flows (off-cycle, dismissal, and `PayrollFlow`) render this directly to prepend
  * their own breadcrumb trail.
  *
  * @internal

package/dist/src/components/Payroll/PayrollExecutionFlow/payrollExecutionMachine.d.ts

@@ -2,14 +2,6 @@ import { BreadcrumbNodes } from '../../Common/FlowBreadcrumbs/FlowBreadcrumbsTyp
 /** @internal */
 export declare const getPayrollExecutionBreadcrumbsNodes: (isDismissal?: boolean) => BreadcrumbNodes;
 /** @internal */
-export declare const calculatedTransition: import('robot3').Transition<"runPayroll/calculated">;
-/** @internal */
-export declare const alreadyProcessedTransition: import('robot3').Transition<"runPayroll/alreadyProcessed">;
-/** @internal */
-export declare const employeeEditTransition: import('robot3').Transition<"runPayroll/employee/edit">;
-/** @internal */
-export declare const blockersViewAllTransition: import('robot3').Transition<"runPayroll/blockers/viewAll">;
-/** @internal */
 export declare const payrollExecutionMachine: {
     configuration: import('robot3').MachineState<any>;
     overview: import('robot3').MachineState<any>;

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

@@ -3,7 +3,7 @@ import { PayrollFlowProps } from './PayrollFlowComponents';
  * Hub for running and managing all payrolls across a company's pay schedules.
  *
  * @remarks
- * Renders the payroll landing page and orchestrates the full run-payroll experience: selecting a payroll, configuring earnings and reimbursements, reviewing totals, submitting, and viewing receipts. Off-cycle, transition, and edit-employee steps are reachable from the same flow.
+ * Renders the payroll landing page and orchestrates the full run-payroll experience: selecting a payroll, configuring earnings and reimbursements, reviewing totals, submitting, and viewing receipts. Off-cycle, transition, and edit-employee steps are reachable from the same flow. Running a transition payroll opens {@link TransitionConfiguration} first. After it saves, the regular payroll steps open for the same payroll.
  *
  * @events
  * | Event | Description | Data |
@@ -23,14 +23,16 @@ import { PayrollFlowProps } from './PayrollFlowComponents';
  * | `runPayroll/summary/viewed` | The summary screen is opened | `{ payrollId: string }` |
  * | `runPayroll/receipt/viewed` | The receipt screen is opened | `{ payrollId: string }` |
  * | `runPayroll/offCycle/start` | The user starts an off-cycle payroll | — |
- * | `transition/runPayroll` | The user starts a pending transition payroll | — |
+ * | `transition/runPayroll` | The user clicks Run on a transition payroll in the alert | `{ payrollUuid: string, startDate: string, endDate: string, payScheduleUuid: string }` |
+ * | `transition/payrollSelected` | The user clicks Run on a transition payroll in the payroll list | `{ payrollUuid: string, payPeriod: object }` |
+ * | `transition/configured` | The transition payroll settings are saved | `{ payrollUuid: string, payrollPrepared: object }` |
  * | `payroll/saveAndExit` | The user clicks Save and Exit | — |
  *
  * @components
  * - {@link PayrollLanding}
  * - {@link PayrollExecutionFlow}
  * - {@link OffCycleFlow}
- * - {@link TransitionFlow}
+ * - {@link TransitionConfiguration}
  * - {@link PayrollBlockerList}
  * - {@link PayrollOverview}
  * - {@link PayrollReceipts}

package/dist/src/components/Payroll/PayrollFlow/PayrollFlowComponents.d.ts

@@ -53,9 +53,6 @@ export interface PayrollFlowContextInterface extends FlowContextInterface {
     showPayrollCancelledAlert?: boolean;
     hasPayrollSubmissionStarted?: boolean;
     executionInitialState?: 'configuration' | 'overview';
-    transitionStartDate?: string;
-    transitionEndDate?: string;
-    transitionPayScheduleUuid?: string;
 }
 /** @internal */
 export declare function PayrollLandingContextual(): import('react').JSX.Element;
@@ -70,4 +67,6 @@ export declare function PayrollReceiptsContextual(): import('react').JSX.Element
 /** @internal */
 export declare function PayrollBlockerContextual(): import('react').JSX.Element;
 /** @internal */
+export declare function TransitionConfigurationContextual(): import('react').JSX.Element;
+/** @internal */
 export declare function SaveAndExitCta(): import('react').JSX.Element | null;

package/dist/src/components/Payroll/PayrollFlow/payrollStateMachine.d.ts

@@ -8,6 +8,6 @@ export declare const payrollFlowMachine: {
     blockers: import('robot3').MachineState<any>;
     submittedOverview: import('robot3').MachineState<any>;
     submittedReceipts: import('robot3').MachineState<any>;
-    transition: import('robot3').MachineState<any>;
+    transitionConfiguration: import('robot3').MachineState<any>;
     offCycle: import('robot3').MachineState<any>;
 };

package/dist/src/components/Payroll/PayrollHistory/PayrollHistoryPresentation.d.ts

@@ -1,4 +1,4 @@
-import { Payroll } from '@gusto/embedded-api/models/components/payrollshow';
+import { Payroll } from '@gusto/embedded-api/models/components/unprocessedpayroll';
 import { WireInRequest } from '@gusto/embedded-api/models/components/wireinrequest';
 import { PaginationControlProps } from '../../Common/PaginationControl/PaginationControlTypes';
 import { UseDateRangeFilterResult } from '../../../hooks/useDateRangeFilter/useDateRangeFilter';

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

@@ -25,12 +25,13 @@ export interface PayrollLandingProps extends BaseComponentInterface<'Payroll.Pay
  * | Event | Description | Data |
  * | ----- | ----------- | ---- |
  * | `runPayroll/selected` | User selected a payroll to run | `{ payrollUuid: string, payPeriod: object }` |
+ * | `transition/payrollSelected` | User selected a transition payroll to run from the payroll list | `{ payrollUuid: string, payPeriod: object }` |
  * | `payroll/review` | User selected a calculated payroll to review | `{ payrollUuid: string, payPeriod: object }` |
  * | `payroll/skipped` | A payroll was skipped | `{ payrollId: string }` |
  * | `payroll/deleted` | A cancellable off-cycle payroll was deleted | `{ payrollId: string }` |
  * | `runPayroll/offCycle/start` | User clicked the Run off-cycle call-to-action | — |
- * | `transition/runPayroll` | User chose to run an unprocessed transition payroll from the Transition Payroll Alert | `{ startDate: string, endDate: string, payScheduleUuid?: string }` |
- * | `transition/payrollSkipped` | User skipped an unprocessed transition payroll from the Transition Payroll Alert | `{ startDate: string, endDate: string, payScheduleUuid?: string }` |
+ * | `transition/runPayroll` | User chose to run an unprocessed transition payroll from the Transition Payroll Alert | `{ payrollUuid?: string, startDate: string, endDate: string, payScheduleUuid?: string }` |
+ * | `transition/payrollSkipped` | User skipped an unprocessed transition payroll from the Transition Payroll Alert | `{ payrollUuid?: string, startDate: string, endDate: string, payScheduleUuid?: string }` |
  * | `runPayroll/summary/viewed` | User opened a payroll's summary view | `{ payrollId: string }` |
  * | `runPayroll/receipt/viewed` | User opened a payroll's receipt view | `{ payrollId: string }` |
  * | `runPayroll/blockers/viewAll` | User opened the full list of payroll blockers | — |
@@ -39,14 +40,26 @@ export interface PayrollLandingProps extends BaseComponentInterface<'Payroll.Pay
  * | `runPayroll/cancelled/alertDismissed` | User dismissed the payroll-cancelled success alert | — |
  *
  * When unprocessed transition pay periods exist, the landing surface renders a Transition
- * Payroll Alert. It looks ahead 90 days for upcoming transition periods, groups them by pay
- * schedule, and offers to run or skip each one. Choosing to run emits `transition/runPayroll`
- * (handle it by rendering `Payroll.TransitionFlow` with the supplied dates and pay schedule).
+ * Payroll Alert. It looks ahead 90 days for upcoming transition periods and lists every one
+ * that hasn't been run, grouped by pay schedule, with run and skip actions on each row.
+ * Clicking Run emits `transition/runPayroll`. If the payroll is already calculated, the button
+ * reads Review and submit and emits `payroll/review` instead, like the payroll list.
  * Skipping opens a confirmation dialog — warning that employees will not be paid for the
  * period — then skips the payroll and emits `transition/payrollSkipped`. Transition pay
  * periods should be resolved (run or skipped) before regular payrolls are run; the Gusto API
  * may reject regular payrolls while unresolved transition periods exist.
  *
+ * `PayrollLanding` emits these events but doesn't change screens on them. `PayrollFlow`
+ * handles the routing for you. If you render `PayrollLanding` yourself, route on these events:
+ *
+ * - `transition/runPayroll` (alert) or `transition/payrollSelected` (payroll list): render
+ *   {@link TransitionConfiguration} with the event's `payrollUuid` as `payrollId`.
+ * - `transition/configured` (from `TransitionConfiguration`): render
+ *   {@link PayrollExecutionFlow} for the same payroll.
+ * - `runPayroll/selected`: render `PayrollExecutionFlow` for the event's `payrollUuid`.
+ * - `payroll/review`: render `PayrollExecutionFlow` for the event's `payrollUuid` with
+ *   `initialState="overview"`. Calculated transition payrolls use this event too.
+ *
  * @param props - See {@link PayrollLandingProps}.
  * @returns The payroll landing flow.
  * @public

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

@@ -22,16 +22,22 @@ export interface PayrollListBlockProps extends BaseComponentInterface<never> {
  * When the company has unprocessed transition pay periods within the next
  * 90 days, the Run Payroll action on Regular rows is disabled to prevent a
  * regular payroll from being run before the transition is resolved. Off-cycle
- * rows and the Run off-cycle action remain enabled, since off-cycle is the
- * path used to run a transition payroll. {@link PayrollLanding} pairs this
- * list with an alert that lets users run or skip the pending transition; when
- * using `PayrollList` directly, render an equivalent resolution surface
- * alongside it.
+ * rows, including transition payroll rows, and the Run off-cycle action stay
+ * enabled.
+ *
+ * Running a transition payroll row emits `transition/payrollSelected` instead
+ * of `runPayroll/selected`. Handle it by rendering
+ * {@link TransitionConfiguration} with the event's `payrollUuid` as
+ * `payrollId`, then render {@link PayrollExecutionFlow} for the same payroll on
+ * `transition/configured`. {@link PayrollLanding} also shows an alert that lets
+ * users run or skip each pending transition payroll. When using `PayrollList`
+ * directly, give users a way to run or skip those payrolls alongside it.
  *
  * @events
  * | Event | Description | Data |
  * | ----- | ----------- | ---- |
  * | `runPayroll/selected` | User selected a payroll to run | `{ payrollUuid, payPeriod }` |
+ * | `transition/payrollSelected` | User selected a transition payroll to run | `{ payrollUuid, payPeriod }` |
  * | `payroll/review` | User selected a calculated payroll to review and submit | `{ payrollUuid, payPeriod }` |
  * | `payroll/skipped` | A payroll was successfully skipped | `{ payrollId }` |
  * | `payroll/deleted` | A cancellable off-cycle payroll was successfully deleted | `{ payrollId }` |

package/dist/src/components/Payroll/PayrollList/PayrollListPresentation.d.ts

@@ -1,5 +1,5 @@
-import { Payroll } from '@gusto/embedded-api/models/components/payrollshow';
-import { PayScheduleShow } from '@gusto/embedded-api/models/components/payscheduleshow';
+import { Payroll } from '@gusto/embedded-api/models/components/unprocessedpayroll';
+import { PayScheduleShow } from '@gusto/embedded-api/models/components/payschedulelistitem';
 import { WireInRequest } from '@gusto/embedded-api/models/components/wireinrequest';
 import { ApiPayrollBlocker } from '../PayrollBlocker/payrollHelpers';
 import { PaginationControlProps } from '../../Common/PaginationControl/PaginationControlTypes';

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

@@ -1,4 +1,4 @@
-import { PayrollShow } from '@gusto/embedded-api/models/components/payrollshow';
+import { PayrollShow } from '@gusto/embedded-api/models/components/unprocessedpayroll';
 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';

package/dist/src/components/Payroll/{UNSTABLE_PayrollEditEmployee/UNSTABLE_PayrollEditEmployee.d.ts → RropPayrollEditEmployee/RropPayrollEditEmployee.d.ts}

@@ -1,11 +1,15 @@
 import { PayrollEditEmployeeProps } from '../PayrollEditEmployee/PayrollEditEmployee';
 /**
- * In-development regular-rate-of-pay rebuild of {@link PayrollEditEmployee}.
+ * Regular rate of pay (RRoP) 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 /
+ * Not exported and not part of the public SDK surface. Partners reach it only through
+ * `PayrollEditEmployee`, which renders it in place of the legacy editor unless the
+ * `regularRateOfPay` flag in {@link Features} is set to `false`. Once that flag is removed, this
+ * component replaces `PayrollEditEmployee` as the public export, and the
+ * `Payroll.RropPayrollEditEmployee` translation namespace is renamed with it.
+ *
+ * Consumes {@link usePayrollEditEmployeeForm} and renders the header, the hours /
  * additional-earnings / time-off / 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,
@@ -17,4 +21,4 @@ import { PayrollEditEmployeeProps } from '../PayrollEditEmployee/PayrollEditEmpl
  *
  * @internal
  */
-export declare function UNSTABLE_PayrollEditEmployee({ FallbackComponent, LoaderComponent, ...props }: PayrollEditEmployeeProps): import('react').JSX.Element;
+export declare function RropPayrollEditEmployee({ FallbackComponent, LoaderComponent, ...props }: PayrollEditEmployeeProps): import('react').JSX.Element;

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

@@ -0,0 +1,55 @@
+import { TransitionConfigurationProps } from './TransitionConfigurationTypes';
+/**
+ * Lets the user change the settings of a transition payroll before running it.
+ *
+ * @remarks
+ * The API creates a transition payroll when a company changes pay schedules. This component
+ * updates that payroll. It never creates one.
+ *
+ * - The pay period, pay schedule, and payment date are shown but can't be changed.
+ * - The user can choose to take or skip regular deductions, and how to withhold taxes.
+ *
+ * If a setting is empty, deductions are taken, the regular tax rate is used, and the pay frequency
+ * matches the pay schedule. The payment date is read only for now. Saving can still move it, and
+ * the form shows the new date.
+ *
+ * `PayrollFlow` renders this component for you. To build the screens yourself:
+ *
+ * 1. Get the transition payroll ID. {@link PayrollLanding} sends it as `payrollUuid` with
+ *    `transition/runPayroll`, and {@link PayrollList} sends it with `transition/payrollSelected`.
+ *    To look it up without those components, call
+ *    `GET /v1/companies/{company_id}/pay_periods?payroll_types=transition` and read
+ *    `payroll.payroll_uuid` from the pay period.
+ * 2. Render this component with that ID as `payrollId`.
+ * 3. On `transition/configured`, render {@link PayrollExecutionFlow} with the same `payrollId`.
+ *    It opens on `PayrollConfiguration`, then continues to review, submit, and receipts.
+ *
+ * @events
+ * | Event | Description | Data |
+ * | ----- | ----------- | ---- |
+ * | `transition/configured` | The settings were saved | `{ payrollUuid: string, payrollPrepared: PayrollPrepared }` |
+ *
+ * @param props - See {@link TransitionConfigurationProps}.
+ * @returns The transition payroll settings form.
+ * @public
+ *
+ * @example
+ * ```tsx
+ * import { componentEvents, Payroll } from '@gusto/embedded-react-sdk'
+ *
+ * function TransitionPayrollPage({ companyId, payrollId }: { companyId: string; payrollId: string }) {
+ *   return (
+ *     <Payroll.TransitionConfiguration
+ *       companyId={companyId}
+ *       payrollId={payrollId}
+ *       onEvent={type => {
+ *         if (type === componentEvents.TRANSITION_CONFIGURED) {
+ *           navigate(`/payrolls/${payrollId}/run`)
+ *         }
+ *       }}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+export declare function TransitionConfiguration(props: TransitionConfigurationProps): import('react').JSX.Element;

package/dist/src/components/Payroll/TransitionConfiguration/TransitionConfigurationPresentation.d.ts

@@ -0,0 +1,9 @@
+import { TransitionConfigurationPresentationProps } from './TransitionConfigurationTypes';
+/**
+ * Layout for the transition payroll settings form.
+ *
+ * @param props - {@link TransitionConfigurationPresentationProps}.
+ * @returns The form layout.
+ * @internal
+ */
+export declare function TransitionConfigurationPresentation({ className, payPeriodStartDate, payPeriodEndDate, payScheduleName, checkDate, isPending, taxWithholdingConfig, isTaxWithholdingModalOpen, onTaxWithholdingEditClick, onTaxWithholdingModalDone, onTaxWithholdingModalCancel, }: TransitionConfigurationPresentationProps): import('react').JSX.Element;

package/dist/src/components/Payroll/TransitionConfiguration/TransitionConfigurationTypes.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { OffCycleTaxWithholdingConfig } from '../OffCycleTaxWithholdingTable/OffCycleTaxWithholdingTableTypes';
+import { BaseComponentInterface } from '../../Base/Base';
+/**
+ * Props for {@link TransitionConfiguration}.
+ *
+ * @public
+ */
+export interface TransitionConfigurationProps extends BaseComponentInterface<'Payroll.TransitionConfiguration'> {
+    /** The company ID. */
+    companyId: string;
+    /** The ID of the transition payroll to update. */
+    payrollId: string;
+}
+/**
+ * Values in the transition payroll settings form.
+ *
+ * @internal
+ */
+export interface TransitionConfigurationFormData {
+    /** `true` to skip regular deductions. */
+    skipRegularDeductions: boolean;
+}
+/** @internal */
+export declare function createTransitionConfigurationSchema(): z.ZodObject<{
+    skipRegularDeductions: z.ZodBoolean;
+}, z.core.$strip>;
+/** @internal */
+export interface TransitionConfigurationPresentationProps {
+    /** Class name for the root element. */
+    className?: string;
+    /** First day of the pay period (YYYY-MM-DD). */
+    payPeriodStartDate?: string | null;
+    /** Last day of the pay period (YYYY-MM-DD). */
+    payPeriodEndDate?: string | null;
+    /** Pay schedule name, or `null` if unknown. */
+    payScheduleName: string | null;
+    /** Payment date (YYYY-MM-DD), or `null` if unknown. */
+    checkDate: string | null;
+    /** `true` while saving. */
+    isPending?: boolean;
+    /** Tax withholding settings shown in the table. */
+    taxWithholdingConfig: OffCycleTaxWithholdingConfig;
+    /** `true` when the tax withholding modal is open. */
+    isTaxWithholdingModalOpen: boolean;
+    /** Called when the user clicks Edit on the tax table. */
+    onTaxWithholdingEditClick: () => void;
+    /** Called when the user saves new tax settings in the modal. */
+    onTaxWithholdingModalDone: (config: OffCycleTaxWithholdingConfig) => void;
+    /** Called when the user closes the modal without saving. */
+    onTaxWithholdingModalCancel: () => void;
+}

package/dist/src/components/Payroll/TransitionConfiguration/index.d.ts

@@ -0,0 +1,2 @@
+export { TransitionConfiguration } from './TransitionConfiguration';
+export type { TransitionConfigurationProps } from './TransitionConfigurationTypes';

package/dist/src/components/Payroll/TransitionPayrollAlert/TransitionPayrollAlertPresentation.d.ts

@@ -3,13 +3,16 @@ import { PayPeriod } from '@gusto/embedded-api/models/components/payperiod';
 export interface TransitionPayPeriodGroup {
     /** UUID of the pay schedule these transition pay periods belong to. */
     payScheduleUuid: string;
-    /** Display name of the pay schedule, shown when multiple groups are rendered. */
+    /** Display name of the pay schedule, shown under each pay period's dates when several are listed. */
     payScheduleName: string;
     /** Unprocessed transition pay periods for this pay schedule. */
     payPeriods: PayPeriod[];
 }
 interface TransitionPayrollAlertPresentationProps {
     groupedPayPeriods: TransitionPayPeriodGroup[];
+    /** IDs of payrolls that are already calculated. These rows show Review and submit instead of Run. */
+    calculatedPayrollUuids?: string[];
+    /** Called when the user clicks Run or Review and submit on a row. */
     onRunPayroll: (payPeriod: PayPeriod) => void;
     onSkipPayroll: (payPeriod: PayPeriod) => void;
     showSkipSuccessAlert: boolean;
@@ -23,5 +26,5 @@ interface TransitionPayrollAlertPresentationProps {
     hasBlockers?: boolean;
 }
 /** @internal */
-export declare function TransitionPayrollAlertPresentation({ groupedPayPeriods, onRunPayroll, onSkipPayroll, showSkipSuccessAlert, onDismissSkipSuccessAlert, skippingPayPeriod, hasBlockers, }: TransitionPayrollAlertPresentationProps): import('react').JSX.Element | null;
+export declare function TransitionPayrollAlertPresentation({ groupedPayPeriods, calculatedPayrollUuids, onRunPayroll, onSkipPayroll, showSkipSuccessAlert, onDismissSkipSuccessAlert, skippingPayPeriod, hasBlockers, }: TransitionPayrollAlertPresentationProps): import('react').JSX.Element | null;
 export {};

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

@@ -3,8 +3,8 @@ import { FixedCompensations, Reimbursements as Reimbursement, PayrollEmployeeCom
 import { PayrollUpdateReimbursements } from '@gusto/embedded-api/models/components/payrollupdate';
 import { PayrollFixedCompensationTypesType } from '@gusto/embedded-api/models/components/payrollfixedcompensationtypestype';
 import { TFunction } from 'i18next';
-import { PayScheduleShow as PayScheduleObject } from '@gusto/embedded-api/models/components/payscheduleshow';
-import { Payroll } from '@gusto/embedded-api/models/components/payrollshow';
+import { PayScheduleShow as PayScheduleObject } from '@gusto/embedded-api/models/components/payschedulelistitem';
+import { Payroll } from '@gusto/embedded-api/models/components/unprocessedpayroll';
 import { PayrollType } from './PayrollList/types';
 import { PayrollCategory } from './payrollTypes';
 import { useDateFormatter } from '../../hooks/useDateFormatter';

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

@@ -36,9 +36,5 @@ export { DismissalFlow } from './Dismissal';
 export type { DismissalFlowProps } from './Dismissal';
 export { DismissalPayPeriodSelection } from './Dismissal';
 export type { DismissalPayPeriodSelectionProps } from './Dismissal';
-export { TransitionFlow } from './Transition';
-export type { TransitionFlowProps } from './Transition';
-export { TransitionCreation } from './TransitionCreation';
-export type { TransitionCreationProps, TransitionCreationFormData } from './TransitionCreation';
-export { TransitionPayroll } from './TransitionPayroll';
-export type { TransitionPayrollProps } from './TransitionPayroll';
+export { TransitionConfiguration } from './TransitionConfiguration';
+export type { TransitionConfigurationProps } from './TransitionConfiguration';

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

@@ -1,5 +1,5 @@
-import { PayrollPrepared } from '@gusto/embedded-api/models/components/payrollshow';
-import { PayScheduleShow } from '@gusto/embedded-api/models/components/payscheduleshow';
+import { PayrollPrepared } from '@gusto/embedded-api/models/components/unprocessedpayroll';
+import { PayScheduleShow } from '@gusto/embedded-api/models/components/payschedulelistitem';
 interface UsePreparedPayrollDataParams {
     companyId: string;
     payrollId: string;

package/dist/src/contexts/ApiProvider/payScheduleCustomNameHook.d.ts

@@ -0,0 +1,14 @@
+import { AfterSuccessHook } from '../../types/hooks';
+/**
+ * Temporary workaround for a pay-schedule response compatibility gap: `custom_name` is generated as
+ * a non-nullable optional string (`z.string().optional()`) in `@gusto/embedded-api`, so a response
+ * with `custom_name: null` throws an `SDKValidationError` -- rejecting the whole pay schedule list
+ * response, not just the one affected item. This afterSuccess hook deletes an explicit
+ * `custom_name: null` before the SDK's zod parse, collapsing it to the same "omitted" shape the
+ * schema already accepts and that pay schedule display and form initialization already default to
+ * an empty string for. Omission, valid strings, and unrelated fields are left untouched. Remove once
+ * the generated client accepts `custom_name: null` directly.
+ *
+ * @internal
+ */
+export declare const payScheduleCustomNameHook: AfterSuccessHook;

package/dist/src/contexts/ApiProvider/payScheduleCustomNameHook.test.d.ts

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

package/dist/src/contexts/ComponentAdapter/componentAdapterTypes.d.ts

@@ -19,7 +19,7 @@ export type { RadioProps } from '../../components/Common/UI/Radio/RadioTypes';
 export type { RadioGroupProps, RadioGroupOption, } from '../../components/Common/UI/RadioGroup/RadioGroupTypes';
 export type { SelectProps, SelectOption } from '../../components/Common/UI/Select/SelectTypes';
 export type { SwitchProps } from '../../components/Common/UI/Switch/SwitchTypes';
-export type { TableProps, TableData, TableRow } from '../../components/Common/UI/Table/TableTypes';
+export type { TableProps, TableData, TableRow, TableHeaderData, TableSortControls, TableSortDirection, } from '../../components/Common/UI/Table/TableTypes';
 export type { TextInputProps } from '../../components/Common/UI/TextInput/TextInputTypes';
 export type { AlertProps } from '../../components/Common/UI/Alert/AlertTypes';
 export type { BadgeProps } from '../../components/Common/UI/Badge/BadgeTypes';

package/dist/src/contexts/FeaturesProvider/FeaturesProvider.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { Features } from './useFeature';
+/** @internal */
+export interface FeaturesProviderProps {
+    children: ReactNode;
+    value?: Features;
+}
+/**
+ * Provides the {@link Features} flags to SDK components via {@link FeaturesContext}.
+ *
+ * @remarks
+ * Composed by `GustoProvider` so the `features` prop flows down to any SDK Flow or Block that
+ * checks {@link useFeature}. The context value is keyed on its sorted, serialized content rather
+ * than the `value` object's identity — the returned reference only changes when a flag's value
+ * actually changes, and adding a new flag to {@link Features} needs no update here.
+ *
+ * @param props - See {@link FeaturesProviderProps}.
+ * @returns A React subtree with the features context applied.
+ * @internal
+ */
+export declare function FeaturesProvider({ children, value }: FeaturesProviderProps): import('react').JSX.Element;

package/dist/src/contexts/FeaturesProvider/useFeature.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Flags for turning released SDK functionality on or off.
+ *
+ * @remarks
+ * Pass to {@link GustoProvider} via the `features` prop. Each flag documents its default and what
+ * changes when you set it. Omitted flags use their default.
+ *
+ * @public
+ * @page providers
+ */
+export interface Features {
+    /**
+     * Regular rate of pay (RRoP) support: per-workweek overtime in payroll editing, and the pay
+     * schedule workweek start day it depends on.
+     *
+     * When `true`, `Payroll.PayrollEditEmployee` renders the RRoP editor, where adding overtime for an
+     * overtime-eligible employee on a multi-workweek payroll splits hours and overtime-affecting
+     * earnings into one column per workweek. `Payroll.PayrollConfiguration` shows each employee's
+     * total pay as the gross pay returned by the API. `usePayScheduleForm` exposes
+     * `Fields.WorkweekStartDay` and submits `workweekStartDay`, so the pay schedule forms in
+     * `CompanyOnboarding.PaySchedule` and `CompanyManagement.PaySchedule` show the field.
+     *
+     * When `false`, `Payroll.PayrollEditEmployee` renders the previous editor, which edits total hours
+     * for the whole pay period and sends no per-workweek breakdowns. `Payroll.PayrollConfiguration`
+     * estimates total pay from hours and pay rates. `Fields.WorkweekStartDay` is `undefined` and
+     * `workweekStartDay` is not submitted.
+     *
+     * Every flow that renders these screens follows the flag, including `Payroll.PayrollFlow`,
+     * `Payroll.PayrollExecutionFlow`, `Payroll.OffCycleFlow`, `Payroll.DismissalFlow`, and
+     * `CompanyOnboarding.OnboardingFlow`.
+     *
+     * @defaultValue `true`
+     */
+    regularRateOfPay?: boolean;
+}
+/**
+ * React context backing {@link useFeature}.
+ *
+ * @internal
+ */
+export declare const FeaturesContext: import('react').Context<Features>;
+/**
+ * Reads whether `feature` is enabled via {@link GustoProvider}'s `features` prop.
+ *
+ * @remarks
+ * Only an explicit `false` disables a flag, so omitting it — or rendering outside a
+ * `GustoProvider` — leaves the functionality on.
+ *
+ * @param feature - The {@link Features} flag to read.
+ * @returns `false` when `feature` is explicitly set to `false`, otherwise `true`.
+ * @internal
+ */
+export declare const useFeature: (feature: keyof Features) => boolean;

package/dist/src/contexts/GustoProvider/GustoProviderCustomUIAdapter.d.ts

@@ -2,6 +2,7 @@ import { default as React, JSX, ReactNode } from 'react';
 import { QueryClient } from '@tanstack/react-query';
 import { ComponentsContextType } from '../ComponentAdapter/useComponentContext';
 import { UnstableFeatures } from '../UnstableFeaturesProvider/useUnstableFeature';
+import { Features } from '../FeaturesProvider/useFeature';
 import { GustoSDKTheme } from '../ThemeProvider/theme';
 import { GlobalResourceDictionary } from '../../types/Helpers';
 import { SDKHooks } from '../../types/hooks';
@@ -63,6 +64,8 @@ export interface GustoBaseProviderProps {
     LoaderComponent?: ({ children }: {
         children?: ReactNode;
     }) => JSX.Element;
+    /** Flags for turning released SDK functionality on or off. Omitted flags use their default. See {@link Features}. */
+    features?: Features;
     /**
      * Opt-in flags for alpha SDK functionality. See {@link UnstableFeatures}.
      * @alpha

package/dist/src/contexts/UnstableFeaturesProvider/useUnstableFeature.d.ts

@@ -4,24 +4,52 @@
  * @remarks
  * Pass to {@link GustoProvider} via the `unstableFeatures` prop to enable a feature ahead of its
  * public release. Every flag defaults to disabled when omitted. When a feature graduates to
- * public release, its flag is deleted from this interface along with the conditional checks that
- * read it — there is no deprecation step. This interface may have no flags at all at any given
- * time — e.g. immediately after the last active flag graduates and before the next one is added —
- * the opt-in mechanism itself is permanent even when nothing is currently gated behind it.
+ * public release, its flag is deleted from this interface — there is no deprecation step. The
+ * conditional checks that read it are deleted too, or moved to a {@link Features} flag when the
+ * released feature still needs a way to turn it off. This interface may have no flags at all
+ * at any given time — e.g. immediately after the last active flag graduates and before the next
+ * one is added — the opt-in mechanism itself is permanent even when nothing is currently gated
+ * behind it.
  *
  * @alpha
  */
 export interface UnstableFeatures {
-    /** Enables recording past payments to contractors within the `ContractorManagement` flows. */
+    /**
+     * Recording contractor payments that were made outside of Gusto.
+     *
+     * When `true`, `ContractorManagement.PaymentsList` (and `ContractorManagement.PaymentFlow`, which
+     * renders it) shows a "Record a historical payment" call to action that opens the historical
+     * payment flow. `ContractorManagement.HistoricalPaymentFlow`,
+     * `ContractorManagement.CreateHistoricalPayment`, and
+     * `ContractorManagement.HistoricalPaymentSummary` can be mounted.
+     *
+     * When `false`, the call to action is hidden and those three components throw when mounted.
+     *
+     * @defaultValue `false`
+     */
     historicalPayments?: boolean;
     /**
-     * Enables the in-development regular-rate-of-pay experience: the payroll editing flow, and the
-     * workweek start day field on `PaySchedule` that RRoP's overtime calculations depend on.
+     * Managing pay schedules and their employee assignments after onboarding.
+     *
+     * When `true`, `CompanyManagement.PaySchedule` and `CompanyManagement.PayScheduleAssignment` can
+     * be mounted.
+     *
+     * When `false`, both components throw when mounted. `CompanyOnboarding.PaySchedule` is not
+     * affected.
+     *
+     * @defaultValue `false`
      */
-    payrollRegularRateOfPay?: boolean;
-    /** Enables the in-development `CompanyManagement.PaySchedule` flow for managing pay schedules and their assignments after onboarding. */
     managePaySchedules?: boolean;
-    /** Enables the in-development `CompanyManagement.TaxPaymentsFlow` for reviewing a company's tax payments and their liabilities. */
+    /**
+     * Reviewing a company's tax payments and their liabilities.
+     *
+     * When `true`, `CompanyManagement.TaxPaymentsFlow`, `CompanyManagement.TaxPaymentsList`, and
+     * `CompanyManagement.TaxPaymentDetail` can be mounted.
+     *
+     * When `false`, all three components throw when mounted.
+     *
+     * @defaultValue `false`
+     */
     taxPayments?: boolean;
 }
 /**

package/dist/src/contexts/index.d.ts

@@ -6,3 +6,4 @@ export * from './ComponentAdapter/componentAdapterTypes';
 export type { GustoSDKTheme, GustoSDKThemeColors } from './ThemeProvider/theme';
 export { useNonce } from './NonceProvider';
 export type { UnstableFeatures } from './UnstableFeaturesProvider/useUnstableFeature';
+export type { Features } from './FeaturesProvider/useFeature';