Functions

function showToast(options: Toast.Options): Promise<Toast>;
function showToast(style: Toast.Style, title: string, message?: string): Promise<Toast>;

interface Toast.Options {
  title: string;
  message?: string;
  style?: Toast.Style; // 'success' | 'failure' | 'animated'
  primaryAction?: {
    title: string;
    onAction?: () => void;
    shortcut?: Keyboard.Shortcut;
  };
  secondaryAction?: {
    title: string;
    onAction?: () => void;
    shortcut?: Keyboard.Shortcut;
  };
}

import { showToast, Toast } from '@raycast/api';

await showToast({
  style: Toast.Style.Success,
  title: 'Task completed',
  message: 'Your file has been saved',
  primaryAction: {
    title: 'Open File',
    onAction: () => open(filePath),
    shortcut: { modifiers: ['cmd'], key: 'o' },
  },
});

function showHUD(
  title: string,
  options?: {
    clearRootSearch?: boolean;
    popToRootType?: PopToRootType;
  }
): Promise<void>;

import { showHUD } from '@raycast/api';

await showHUD('Copied to clipboard!');

function confirmAlert(options: Alert.Options): Promise<boolean>;

interface Alert.Options {
  title: string;
  message?: string;
  icon?: Image.ImageLike;
  primaryAction?: {
    title: string;
    onAction?: () => void;
    style?: Alert.ActionStyle; // 'default' | 'destructive' | 'cancel'
  };
  dismissAction?: {
    title: string;
    onAction?: () => void;
  };
}

import { confirmAlert } from '@raycast/api';

const confirmed = await confirmAlert({
  title: 'Delete File',
  message: 'Are you sure you want to delete this file? This cannot be undone.',
  primaryAction: {
    title: 'Delete',
    style: Alert.ActionStyle.Destructive,
  },
});

if (confirmed) {
  // Delete file
}

function closeMainWindow(options?: {
  clearRootSearch?: boolean;
  popToRootType?: PopToRootType;
}): Promise<void>;

import { closeMainWindow } from '@raycast/api';

await closeMainWindow({ clearRootSearch: true });

function popToRoot(options?: {
  clearRootSearch?: boolean;
}): Promise<void>;

function clearSearchBar(options?: {
  forceScrollToTop?: boolean;
}): Promise<void>;

function open(
  target: string,
  application?: string | Application
): Promise<void>;

import { open } from '@raycast/api';

// Open URL in default browser
await open('https://example.com');

// Open URL in specific browser
await open('https://example.com', 'Safari');

// Open file
await open('/path/to/file.pdf');

// Open file in specific app
await open('/path/to/image.png', 'Preview');

function getApplications(path?: string): Promise<Application[]>;

interface Application {
  name: string;
  path: string;
  bundleId?: string;
}

import { getApplications, List } from '@raycast/api';

export default function Command() {
  const [apps, setApps] = useState<Application[]>([]);
  
  useEffect(() => {
    getApplications().then(setApps);
  }, []);
  
  return (
    <List>
      {apps.map(app => (
        <List.Item key={app.path} title={app.name} />
      ))}
    </List>
  );
}

function getDefaultApplication(path: string): Promise<Application>;

function getFrontmostApplication(): Promise<Application>;

function showInFinder(path: string): Promise<void>;

import { showInFinder } from '@raycast/api';

await showInFinder('/Users/me/Documents/file.pdf');

function trash(paths: string | string[]): Promise<void>;

import { trash, showToast, Toast } from '@raycast/api';

try {
  await trash('/path/to/file.txt');
  await showToast(Toast.Style.Success, 'File moved to trash');
} catch (error) {
  await showToast(Toast.Style.Failure, 'Failed to delete file');
}

function getSelectedText(): Promise<string>;

function getSelectedFinderItems(): Promise<FileSystemItem[]>;

interface FileSystemItem {
  path: string;
}

function launchCommand(options: {
  name: string;
  type: LaunchType;
  extensionName?: string;
  ownerOrAuthorName?: string;
  context?: LaunchContext;
}): Promise<void>;

import { launchCommand, LaunchType } from '@raycast/api';

await launchCommand({
  name: 'search',
  type: LaunchType.UserInitiated,
  extensionName: 'my-extension',
});

function openExtensionPreferences(): Promise<void>;

function openCommandPreferences(): Promise<void>;

function updateCommandMetadata(metadata: {
  subtitle?: string;
}): Promise<void>;

import { updateCommandMetadata } from '@raycast/api';

await updateCommandMetadata({ subtitle: '5 items' });

function getPreferenceValues<T = PreferenceValues>(): T;

import { getPreferenceValues } from '@raycast/api';

interface Preferences {
  apiKey: string;
  showNotifications: boolean;
}

const preferences = getPreferenceValues<Preferences>();
console.log(preferences.apiKey);

function captureException(error: Error): void;

import { captureException } from '@raycast/api';

try {
  // Some operation
} catch (error) {
  captureException(error as Error);
}