segmented machine

type SegmentedChangeReason = "pointer" | "keyboard" | "programmatic";

type SegmentedCommand = CommandObject & ({
  readonly type: "VALUE_CHANGE_REQUEST";
  readonly value: SegmentedSelection;
  readonly reason: SegmentedChangeReason;
} | {
  readonly type: "FOCUS_ITEM";
  readonly key: string;
});

type SegmentedContext = {
  readonly type: SegmentedType;
  readonly value: SegmentedSelection | undefined;
  readonly focusedValue?: string;
  readonly mode: BindingMode;
};

export declare const SegmentedDiagnosticCodes: readonly DiagnosticCatalogueEntry[];

type SegmentedEvent = {
  readonly type: "SELECT";
  readonly value: string;
  readonly reason: SegmentedChangeReason;
} | {
  readonly type: "MOVE";
  readonly direction: -1 | 1;
} | {
  readonly type: "HOME";
} | {
  readonly type: "END";
} | {
  readonly type: "FOCUS";
  readonly value: string;
} | {
  readonly type: "BLUR";
} | {
  readonly type: "RESET";
};

type SegmentedInput = {
  readonly options: readonly SegmentedItem[];
  readonly type?: SegmentedType;
  /** Controlled committed value. A defined empty array is controlled. */
  readonly value?: SegmentedSelection;
  /** Uncontrolled initial value. */
  readonly defaultValue?: SegmentedSelection;
  readonly disabled?: boolean;
  readonly readOnly?: boolean;
  /** Connector hint; the machine receives logical movement only. */
  readonly orientation?: SegmentedOrientation;
  readonly loop?: boolean;
};

interface SegmentedItem {
  readonly value: string;
  readonly disabled?: boolean;
}

export declare const segmentedMachine: SegmentedMachine;

type SegmentedMachine = Machine<SegmentedInput, SegmentedStateValue, SegmentedContext, SegmentedEvent, SegmentedCommand>;

type SegmentedOrientation = "horizontal" | "vertical";

export declare const segmentedReplaySequence: readonly SegmentedEvent[];

type SegmentedSelection = string | readonly string[];

export declare const segmentedSelectors: {
  type: (snapshot: SegmentedSnapshot) => SegmentedType;
  value: (snapshot: SegmentedSnapshot) => SegmentedSelection | undefined;
  focusedValue: (snapshot: SegmentedSnapshot) => string | undefined;
  isSelected: (snapshot: SegmentedSnapshot, value: string) => boolean;
};

type SegmentedSnapshot = Snapshot<SegmentedStateValue, SegmentedContext>;

type SegmentedStateValue = "ready";

type SegmentedType = "single" | "multiple";

type ToggleGroupCommand = SegmentedCommand;

type ToggleGroupContext = SegmentedContext;

type ToggleGroupEvent = SegmentedEvent;

type ToggleGroupInput = SegmentedInput;

type ToggleGroupItem = SegmentedItem;

export declare const toggleGroupMachine: SegmentedMachine;

type ToggleGroupMachine = SegmentedMachine;

export declare const toggleGroupSelectors: {
  type: (snapshot: SegmentedSnapshot) => SegmentedType;
  value: (snapshot: SegmentedSnapshot) => SegmentedSelection | undefined;
  focusedValue: (snapshot: SegmentedSnapshot) => string | undefined;
  isSelected: (snapshot: SegmentedSnapshot, value: string) => boolean;
};

type ToggleGroupSnapshot = SegmentedSnapshot;