forlogic-core 2.2.8 → 2.3.1

package/dist/leadership/types.d.ts

@@ -1,23 +1,603 @@
-export interface Leader {
+import React from 'react';
+export type LoadingState = 'idle' | 'loading' | 'success' | 'error';
+export type ViewMode = 'table';
+export type SortDirection = 'asc' | 'desc';
+export type ActionType = 'create' | 'update' | 'delete' | 'fetch' | 'export';
+/**
+ * Interface mínima que **toda** entidade da plataforma deve estender.
+ *
+ * Reflete os campos obrigatórios de qualquer tabela multi-tenant: `id`, `alias` (tenant),
+ * timestamps e flags de soft delete (`is_removed`) e ativação (`is_actived`).
+ *
+ * @example
+ * // Estendendo para uma entidade de domínio
+ * interface ActionPlan extends BaseEntity {
+ *   title: string;
+ *   description: string | null;
+ *   status: 'pending' | 'in_progress' | 'completed';
+ *   id_user: string;
+ * }
+ *
+ * @example
+ * // Uso genérico em hooks/serviços CRUD
+ * function useEntities<T extends BaseEntity>(table: string) {
+ *   return useQuery<T[]>(['entities', table], () => fetchAll(table));
+ * }
+ */
+export interface BaseEntity {
     id: string;
     alias: string;
-    id_user: string;
-    id_leader: string | null;
-    is_removed: boolean;
-    is_active: boolean;
     created_at: string;
     updated_at: string;
-    name?: string;
-    email?: string;
-    subordinatesCount?: number;
-    subordinateNames?: string[];
+    is_removed: boolean;
+    is_actived: boolean;
+}
+/**
+ * BaseEntityPayload - Payload básico para criação de entidades
+ * IMPORTANTE: Customize conforme as propriedades da sua entidade específica
+ */
+export interface BaseEntityPayload {
+    alias: string;
+}
+export interface QueryParams {
+    page?: number;
+    limit?: number;
+    search?: string;
+    sortField?: string;
+    sortDirection?: SortDirection;
+}
+export interface PaginatedResponse<T = unknown> {
+    data: T[];
+    currentPage: number;
+    totalPages: number;
+    totalItems: number;
+    itemsPerPage: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+}
+export interface SortState {
+    field: string;
+    direction: SortDirection;
+}
+export interface CrudManager<T extends BaseEntity> {
+    entities: T[];
+    pagination: PaginatedResponse<T>;
+    isLoading: boolean;
+    isDeleting: boolean;
+    searchTerm: string;
+    sortField: string;
+    sortDirection: SortDirection;
+    currentPage: number;
+    itemsPerPage: number;
+    handleSearch: (search: string) => void;
+    handleSort: (field: string) => void;
+    handlePageChange: (page: number) => void;
+    handleItemsPerPageChange: (limit: number) => void;
+    clearFilters: () => void;
+    deleteEntity: (id: string) => void;
+    refetch: () => void;
+    selectedIds: string[];
+    selectItem: (id: string) => void;
+    selectAll: () => void;
+    clearSelection: () => void;
+    isAllSelected: boolean;
+    bulkDelete?: (ids: string[]) => Promise<void>;
+    isBulkDeleting?: boolean;
+}
+export interface CrudEntity extends BaseEntity {
+}
+/**
+ * Definição de coluna usada por {@link CrudTable} e `createCrudPage`.
+ *
+ * Suporta tipagem semântica (`type`), ordenação (default `true`), filtros, busca textual,
+ * renderização customizada e larguras controladas.
+ *
+ * @example
+ * const columns: CrudColumn<ActionPlan>[] = [
+ *   { key: 'title', header: 'Título', type: 'text', searchable: true, weight: 3 },
+ *   {
+ *     key: 'status',
+ *     header: 'Status',
+ *     type: 'select',
+ *     options: [
+ *       { label: 'Pendente', value: 'pending' },
+ *       { label: 'Concluído', value: 'completed' },
+ *     ],
+ *     filterable: true,
+ *     render: (row) => <StatusBadge status={row.status} />,
+ *   },
+ *   {
+ *     key: 'created_at',
+ *     header: 'Criado em',
+ *     type: 'date',
+ *     sortable: true,
+ *     render: (row) => formatDatetime(row.created_at),
+ *   },
+ *   { key: 'id_user', header: 'Responsável', minWidth: 180 },
+ * ];
+ */
+export interface CrudColumn<T = any> {
+    key: keyof T;
+    header: string;
+    label?: string;
+    type?: 'text' | 'number' | 'date' | 'boolean' | 'select' | 'textarea' | 'email' | 'tel';
+    required?: boolean;
+    /** Coluna é ordenável. Default: true. Use `false` para desabilitar. */
+    sortable?: boolean;
+    filterable?: boolean;
+    searchable?: boolean;
+    options?: Array<{
+        label: string;
+        value: any;
+    }>;
+    render?: (item: T) => React.ReactNode;
+    validation?: (value: any) => string | undefined;
+    className?: string;
+    /** Minimum width in pixels (only applied in desktop view) */
+    minWidth?: number;
+    /** Maximum width in pixels for column resize */
+    maxWidth?: number;
+    /** Flex weight for distributing remaining space (only applied in desktop view) */
+    weight?: number;
+    /** Fixed width (overrides minWidth and weight) */
+    width?: number;
+    /** Whether the column can be resized (default: true when enableColumnResize is enabled) */
+    resizable?: boolean;
+    /** Whether the column can be hidden via column manager (default: true) */
+    hideable?: boolean;
+    /** Whether the column can be used for grouping (default: false) */
+    groupable?: boolean;
+}
+/**
+ * Filtro customizado para páginas CRUD
+ *
+ * Permite adicionar filtros personalizados (busca, selects, checkboxes, etc)
+ * nas páginas CRUD geradas automaticamente.
+ *
+ * **Tipos de filtro:**
+ * - `'search'`: Campo de busca padrão (integrado com `manager.searchTerm`)
+ * - `'select'`: Select nativo com opções predefinidas
+ * - `'custom'`: Componente React customizado (Select, Checkbox, etc)
+ *
+ * **Posicionamento:**
+ * - Desktop: Filtros aparecem inline na Action Bar (ao lado do botão "Novo")
+ * - Mobile: Filtros empilhados verticalmente abaixo do botão "Novo"
+ *
+ * @example
+ * ```typescript
+ * // Filtro de busca padrão
+ * const filters: CrudFilter[] = [
+ *   { type: 'search' }
+ * ];
+ *
+ * // Filtro select nativo
+ * const filters: CrudFilter[] = [
+ *   {
+ *     type: 'select',
+ *     placeholder: 'Filtrar por status',
+ *     options: [
+ *       { label: 'Todos', value: 'all' },
+ *       { label: 'Ativos', value: 'active' },
+ *       { label: 'Inativos', value: 'inactive' }
+ *     ],
+ *     value: statusFilter,
+ *     onChange: setStatusFilter
+ *   }
+ * ];
+ *
+ * // Filtro customizado com Select
+ * import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from 'forlogic-core';
+ *
+ * const filters: CrudFilter[] = [
+ *   {
+ *     type: 'custom',
+ *     component: ({ value, onChange }) => (
+ *       <Select value={value} onValueChange={onChange}>
+ *         <SelectTrigger className="w-[180px]">
+ *           <SelectValue placeholder="Status" />
+ *         </SelectTrigger>
+ *         <SelectContent>
+ *           <SelectItem value="all">Todos</SelectItem>
+ *           <SelectItem value="active">Ativos</SelectItem>
+ *           <SelectItem value="inactive">Inativos</SelectItem>
+ *         </SelectContent>
+ *       </Select>
+ *     ),
+ *     props: { value: statusFilter, onChange: setStatusFilter }
+ *   }
+ * ];
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Múltiplos filtros customizados
+ * function ProcessesPage() {
+ *   const [statusFilter, setStatusFilter] = useState('all');
+ *   const [typeFilter, setTypeFilter] = useState('all');
+ *
+ *   const filters: CrudFilter[] = [
+ *     { type: 'search' },
+ *     {
+ *       type: 'select',
+ *       placeholder: 'Status',
+ *       options: [
+ *         { label: 'Todos', value: 'all' },
+ *         { label: 'Ativos', value: 'active' },
+ *         { label: 'Inativos', value: 'inactive' }
+ *       ],
+ *       value: statusFilter,
+ *       onChange: setStatusFilter
+ *     },
+ *     {
+ *       type: 'custom',
+ *       component: TypeSelect,
+ *       props: { value: typeFilter, onChange: setTypeFilter }
+ *     }
+ *   ];
+ *
+ *   // Filtrar dados baseado nos filtros customizados
+ *   const filteredData = useMemo(() => {
+ *     let data = manager.entities;
+ *     if (statusFilter !== 'all') {
+ *       data = data.filter(item => item.status === statusFilter);
+ *     }
+ *     if (typeFilter !== 'all') {
+ *       data = data.filter(item => item.type === typeFilter);
+ *     }
+ *     return data;
+ *   }, [manager.entities, statusFilter, typeFilter]);
+ *
+ *   return <CrudPage manager={{ ...manager, entities: filteredData }} />;
+ * }
+ * ```
+ *
+ * @see {@link FilterBar} - Componente que renderiza os filtros
+ */
+export interface CrudFilter {
+    /** Tipo do filtro: 'search' para busca padrão, 'select' para select nativo, 'custom' para componente personalizado */
+    type: 'search' | 'select' | 'custom';
+    /** Placeholder para select (quando type='select') */
+    placeholder?: string;
+    /** Opções para select (quando type='select') */
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    /** Valor atual do filtro (quando type='select') */
+    value?: string;
+    /** Callback quando o valor muda (quando type='select') */
+    onChange?: (value: string) => void;
+    /** Componente React customizado (obrigatório quando type='custom') */
+    component?: React.ComponentType<any>;
+    /** Props passadas para o componente customizado (value, onChange, etc) */
+    props?: Record<string, any>;
+    /** Função para controlar visibilidade do filtro baseado no estado do manager */
+    show?: (manager: CrudManager<any>) => boolean;
+}
+export interface BulkAction<T extends BaseEntity> {
+    label: string;
+    icon?: React.ComponentType<{
+        size?: number;
+        className?: string;
+    }>;
+    variant?: 'default' | 'destructive' | 'outline';
+    action: (items: T[]) => void | Promise<void>;
+    confirmMessage?: string;
+    /** Se a ação está desabilitada */
+    disabled?: boolean;
+    /** Motivo do bloqueio (exibido em tooltip quando disabled=true) */
+    disabledReason?: string;
+}
+export interface CrudPageConfig<T extends CrudEntity> {
+    entityName: string;
+    entityNamePlural: string;
+    filters?: CrudFilter[];
+    columns: CrudColumn<T>[];
+    cardFields?: Array<{
+        key: keyof T;
+        label: string;
+        render?: (value: any, item: T) => React.ReactNode;
+    }>;
+    onNew?: () => void;
+    onEdit?: (entity: T) => void;
+    useCustomRouting?: boolean;
+    /** @deprecated Use showNewButton={false} instead */
+    hideNewButton?: boolean;
+    /** Exibir botão "Novo" (default: true) */
+    showNewButton?: boolean;
+    /** Texto customizado para o botão "Novo" */
+    newButtonLabel?: string;
+    newButtonText?: string;
+    title?: string;
+    searchPlaceholder?: string;
+    /** Exibir busca integrada na Action Bar (default: false - usa busca global) */
+    showSearch?: boolean;
+    /** Exibir Action Bar (default: true) */
+    showActionBar?: boolean;
+    enableBulkActions?: boolean;
+    bulkActions?: BulkAction<T>[];
+    customActions?: Array<{
+        label: string;
+        icon?: React.ComponentType<{
+            size?: number;
+            className?: string;
+        }>;
+        variant?: 'default' | 'destructive' | 'outline' | 'ghost';
+        action: () => void;
+        /** Se a ação está desabilitada */
+        disabled?: boolean;
+        /** Motivo do bloqueio (exibido em tooltip quando disabled=true) */
+        disabledReason?: string;
+    }>;
+    customRowActions?: (item: T) => Array<{
+        icon: any;
+        label: string;
+        onClick: () => void;
+    }>;
+    customListView?: (items: T[], manager?: CrudManager<T>) => React.ReactNode;
+    /** Colunas ocultas por padrão (antes de qualquer interação do usuário). */
+    defaultHiddenColumns?: string[];
+}
+export interface EntityWithId {
+    id: string | number;
+}
+export type CreateEntityInput<T extends EntityWithId> = Omit<T, 'id' | 'created_at' | 'updated_at'>;
+export type UpdateEntityInput<T extends EntityWithId> = Partial<CreateEntityInput<T>>;
+export interface GeneratedCrudConfig<T extends EntityWithId> {
+    title: string;
+    columns: CrudColumn<T>[];
+    searchPlaceholder?: string;
+    itemsPerPage?: number;
+    enableCreate?: boolean;
+    enableEdit?: boolean;
+    enableDelete?: boolean;
+    enableSearch?: boolean;
+    enableFilters?: boolean;
+    customActions?: Array<{
+        label: string;
+        icon?: React.ComponentType;
+        onClick: (item: T) => void;
+        variant?: 'default' | 'destructive' | 'outline';
+    }>;
+}
+export interface FormField {
+    name: string;
+    label: string;
+    type: 'text' | 'textarea' | 'select' | 'multiselect' | 'date' | 'datetime-local' | 'number' | 'user-select' | 'group' | 'checkbox' | 'switch' | 'email' | 'password' | 'color' | 'color-picker' | 'icon-picker' | 'custom';
+    required?: boolean;
+    disabled?: boolean;
+    options?: {
+        label: string;
+        value: string | number;
+    }[];
+    placeholder?: string;
+    component?: React.ComponentType<any>;
+    componentProps?: Record<string, any>;
+    value?: any;
+    defaultValue?: any;
+    dependsOn?: string;
+    computedValue?: (formData: any) => any;
+    validation?: {
+        custom?: (value: any, formData?: any) => string | undefined;
+    } | ((value: any, formData?: any) => string | undefined);
+    layout?: 'horizontal' | 'vertical';
+    className?: string;
+    fields?: FormField[];
+    onValueChange?: (value: any) => void;
+    step?: number;
+    rows?: number;
+    mode?: 'single' | 'multiple';
+    columns?: number;
+    render?: (props: {
+        value: any;
+        onChange: (value: any) => void;
+        error?: string;
+        disabled?: boolean;
+    }) => React.ReactNode;
+}
+export interface FormSection {
+    id: string;
+    title: string;
+    label?: string;
+    fields: FormField[];
+    component?: React.ComponentType<any>;
+    disabled?: boolean;
+    condition?: (formData: any) => boolean;
+}
+export interface BaseFormConfig<T> {
+    title: string;
+    sections: FormSection[];
+    initialData?: Partial<T>;
+    onSubmit: (data: T) => void;
+    onCancel: () => void;
+    submitButtonText?: string;
+    isMobile?: boolean;
+}
+export interface BaseFormProps<T> extends BaseFormConfig<T> {
+    open: boolean;
+}
+export interface GenericQueryConfig<TData, TParams> {
+    queryKey: string[];
+    queryFn: (params: TParams) => Promise<TData>;
+    params: TParams;
+    hookName: string;
+    enabled?: boolean;
+    defaultPagination?: {
+        currentPage: number;
+        totalPages: number;
+        totalItems: number;
+        itemsPerPage: number;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+    };
+    dataMapper?: (data: TData) => unknown;
+    dataExtractor?: (response: TData) => unknown;
+    paginationExtractor?: (response: TData) => unknown;
+}
+export interface GenericDataQueryResult<TItem> {
+    data: TItem[];
+    pagination: unknown;
+    isLoading: boolean;
+    error: unknown;
+    refetch: () => void;
+}
+export interface AuthTokens {
+    accessToken: string;
+    idToken: string;
+    supabaseToken?: string;
+}
+export interface UserInfo {
+    id: string;
+    email: string;
+    name: string;
+    identifier: string;
+    alias?: string;
+    isSysAdmin: boolean;
+}
+export interface Company {
+    id: string;
+    alias: string;
+    name: string;
 }
-export interface UnassociatedUser {
+export interface SelectedUnit {
     id: string;
     name: string;
+    alias: string;
+}
+export interface CompanyTokenData {
+    id: string;
+    alias: string;
+    name: string;
+    payload: any;
+}
+export interface AuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    user: UserInfo | null;
+    alias: string | null;
+    companies: Company[];
+    selectedUnit: SelectedUnit | null;
+    userId: string | null;
+    userAlias: string | null;
+    placeId: string | null;
+    placeName: string | null;
+    activePlaceId?: string | null;
+    activePlaceName?: string | null;
+}
+export interface IdTokenPayload {
+    subNewId: string;
     email: string;
+    name: string;
+    identifier: string;
+    default?: string;
+    [key: string]: any;
+}
+export interface AccessTokenPayload {
+    default?: string;
+    [key: string]: any;
+}
+export interface QualiexUser {
+    id?: string;
+    userId?: string;
+    userName?: string;
+    userEmail?: string;
+    placeId?: string | null;
+    placeName?: string | null;
+    roleId?: string;
+    roleName?: string;
+    companyId?: string;
+    companyName?: string;
+    /** Indica se o usuário está ativo no Qualiex. Default `true` quando ausente. */
+    isActive?: boolean;
+}
+export interface QualiexUserFieldMapping {
+    /** Nome do campo de ID de usuário na entidade (ex: "target_user_id") */
+    idField: string;
+    /** Nome do campo de saída para o nome (ex: "target_user_name"). Default: idField + "_name" */
+    nameField?: string;
+    /** Nome do campo de saída para o email (ex: "target_user_email"). Default: idField + "_email" */
+    emailField?: string;
+    /** Nome do campo de saída para o username (ex: "target_user_username"). Default: idField + "_username" */
+    usernameField?: string;
+}
+export interface QualiexEnrichmentConfig {
+    /** Sufixo padrão para campos de nome (default: "_name") */
+    userNameFieldSuffix?: string;
+    /** Sufixo padrão para campos de email (default: "_email") */
+    userEmailFieldSuffix?: string;
+    /** Sufixo padrão para campos de username (default: "_username") */
+    userUsernameFieldSuffix?: string;
+}
+/**
+ * Representa um módulo/software disponível na plataforma Qualiex.
+ * Retornado pela API GET /api/common/v1/softwares
+ */
+export interface Software {
+    id: number;
+    alias: string;
+    color: string;
+    colorLight: string;
+    namePtBr: string;
+    nameUs: string;
+    nameEs: string;
+}
+/**
+ * Representa uma associação do usuário com uma empresa/unidade.
+ * Retornado pela API GET /api/common/v1/Users/{userId}/associations
+ *
+ * O array `softwares` contém os IDs dos módulos aos quais o usuário tem acesso.
+ * O `roleId` e `roleName` representam o papel do usuário naquela associação.
+ */
+export interface UserAssociation {
+    associationId: string;
+    userId: string;
+    userName: string;
+    companyId: string;
+    companyName: string;
+    companyAlias: string;
+    companyPhotoDate?: string;
+    language?: string;
+    roleId: string;
+    roleName: string;
+    placeId?: string;
+    placeName?: string;
+    softwares: number[];
+    functionalities: string[];
+    isQualitfy?: boolean;
+    isMetroex?: boolean;
+}
+/**
+ * Resultado do hook useModuleAccess
+ */
+export interface ModuleAccessResult {
+    /** Se o usuário tem acesso ao módulo configurado/especificado */
+    hasAccess: boolean;
+    /** Se os dados ainda estão carregando */
+    isLoading: boolean;
+    /** Role do usuário na associação atual */
+    role: {
+        id: string;
+        name: string;
+    } | null;
+    /** Associação completa do usuário para a unidade atual */
+    association: UserAssociation | null;
+    /** Função para verificar acesso a outro(s) módulo(s) */
+    hasAccessTo: (alias: string | string[]) => boolean;
+}
+export interface ApiResponse<T = unknown> {
+    data: T;
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings?: string[];
 }
-export interface LeaderNode extends Leader {
-    children: LeaderNode[];
-    level: number;
+export interface NotificationConfig {
+    title: string;
+    description?: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    duration?: number;
 }

package/dist/leadership/utils/color.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gera uma cor de fundo pastel a partir de uma cor hex semântica.
+ * Útil para StatusBadge e outros componentes que precisam de fundo suave.
+ *
+ * @param hex - Cor em formato hex (ex: '#2E7D5B')
+ * @param opacity - Opacidade do fundo (0-1, default 0.1)
+ * @returns String rgba (ex: 'rgba(46, 125, 91, 0.1)')
+ */
+export declare function generatePastelBg(hex: string, opacity?: number): string;
+/**
+ * Calcula a luminância relativa de uma cor hex (WCAG 2.0).
+ * Retorna um valor entre 0 (preto) e 1 (branco).
+ *
+ * @param hex - Cor em formato hex (ex: '#2E7D5B')
+ * @returns Luminância relativa (0-1)
+ */
+export declare function getLuminance(hex: string): number;
+/**
+ * Calcula a razão de contraste entre duas cores (WCAG 2.0).
+ * Razão >= 4.5 atende AA para texto normal; >= 7 atende AAA.
+ *
+ * @param hex1 - Primeira cor hex
+ * @param hex2 - Segunda cor hex
+ * @returns Razão de contraste (1-21)
+ */
+export declare function getContrastRatio(hex1: string, hex2: string): number;

package/dist/leadership/utils/formatters/currencyFormatters.d.ts

@@ -0,0 +1 @@
+export declare const formatCurrency: (value: number | undefined | null, currency?: string, locale?: string) => string;

package/dist/leadership/utils/formatters/dateFormatters.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Formata uma string ISO 8601 para o formato de data/hora especificado,
+ * convertendo para o timezone do usuário
+ *
+ * @param dateString - String de data no formato ISO 8601 (ex: "2024-03-15T14:30:00Z")
+ * @param datetimeFormat - Máscara de formato date-fns (ex: "dd/MM/yyyy HH:mm")
+ * @param timezone - Identificador IANA do fuso horário (ex: "America/Sao_Paulo")
+ * @param locale - Código do locale para formatação de nomes de mês/dia
+ * @returns String formatada no timezone especificado ou mensagem de erro
+ *
+ * @example
+ * ```ts
+ * // Data UTC sendo exibida em Brasília (UTC-3)
+ * formatDatetime("2024-03-15T17:30:00Z", "dd/MM/yyyy HH:mm", "America/Sao_Paulo");
+ * // "15/03/2024 14:30"
+ *
+ * // Mesma data em Tokyo (UTC+9)
+ * formatDatetime("2024-03-15T17:30:00Z", "dd/MM/yyyy HH:mm", "Asia/Tokyo");
+ * // "16/03/2024 02:30"
+ *
+ * // Com formato americano
+ * formatDatetime("2024-03-15T17:30:00Z", "MM/dd/yyyy hh:mm a", "America/New_York", "en-US");
+ * // "03/15/2024 01:30 PM"
+ * ```
+ */
+export declare const formatDatetime: (dateString: string, datetimeFormat?: string, timezone?: string, locale?: string) => string;
+/**
+ * Formata uma string ISO 8601 para formato de data localizado (sem hora),
+ * convertendo para o timezone do usuário
+ *
+ * Usa o formato 'PP' do date-fns que se adapta automaticamente ao locale:
+ * - pt-BR: "15 de mar. de 2024"
+ * - en-US: "Mar 15, 2024"
+ * - es-ES: "15 mar 2024"
+ *
+ * @param dateString - String de data no formato ISO 8601
+ * @param locale - Código do locale para formatação
+ * @param timezone - Identificador IANA do fuso horário (para determinar a data correta)
+ * @returns String formatada ou mensagem de erro
+ *
+ * @example
+ * ```ts
+ * // Data UTC às 23:00 em Brasília ainda é dia 15
+ * formatDate("2024-03-15T23:00:00Z", "pt-BR", "America/Sao_Paulo");
+ * // "15 de mar. de 2024"
+ *
+ * // Mas em Tokyo (UTC+9) já é dia 16
+ * formatDate("2024-03-15T23:00:00Z", "en-US", "Asia/Tokyo");
+ * // "Mar 16, 2024"
+ * ```
+ */
+export declare const formatDate: (dateString: string, locale?: string, timezone?: string) => string;