@abpjs/language-management 0.7.2

package/dist/index.d.ts

@@ -0,0 +1,476 @@
+import { ABP, RestService } from '@abpjs/core';
+import React from 'react';
+
+/**
+ * Language Management Models
+ * Translated from @volo/abp.ng.language-management v0.7.2
+ */
+
+/**
+ * Language Management namespace containing all models
+ * for language and language text management.
+ */
+declare namespace LanguageManagement {
+    /**
+     * State interface for language management
+     */
+    interface State {
+        languageResponse: LanguageResponse;
+        languageTextsResponse: LanguageTextResponse;
+        selectedItem: Language | null;
+        cultures: Culture[];
+        resources: Resource[];
+    }
+    /**
+     * Paginated response of languages
+     */
+    type LanguageResponse = ABP.PagedResponse<Language>;
+    /**
+     * Paginated response of language texts
+     */
+    type LanguageTextResponse = ABP.PagedResponse<LanguageText>;
+    /**
+     * Culture information for localization
+     */
+    interface Culture {
+        displayName: string;
+        name: string;
+    }
+    /**
+     * Resource containing localization strings
+     */
+    interface Resource {
+        name: string;
+    }
+    /**
+     * Language entity
+     */
+    interface Language {
+        id: string;
+        cultureName: string;
+        uiCultureName: string;
+        displayName: string;
+        flagIcon: string;
+        isEnabled: boolean;
+        isDefaultLanguage: boolean;
+        creationTime: string;
+        creatorId: string;
+    }
+    /**
+     * Input for updating a language
+     */
+    interface UpdateLanguageInput {
+        isEnabled: boolean;
+        flagIcon: string;
+        displayName: string;
+    }
+    /**
+     * Input for creating a new language
+     */
+    interface CreateLanguageInput extends UpdateLanguageInput {
+        cultureName: string;
+        uiCultureName: string;
+    }
+    /**
+     * Language text (localization string) entity
+     */
+    interface LanguageText {
+        resourceName: string;
+        cultureName: string;
+        baseCultureName: string;
+        baseValue: string;
+        name: string;
+        value: string;
+    }
+    /**
+     * Query parameters for fetching language texts
+     */
+    interface LanguageTextQueryParams extends ABP.PageQueryParams {
+        resourceName?: string;
+        baseCultureName: string;
+        targetCultureName: string;
+        getOnlyEmptyValues: boolean;
+    }
+    /**
+     * Parameters for requesting a language text by name
+     */
+    interface LanguageTextRequestByNameParams {
+        resourceName: string;
+        cultureName: string;
+        name: string;
+    }
+    /**
+     * Parameters for updating a language text by name
+     */
+    interface LanguageTextUpdateByNameParams extends LanguageTextRequestByNameParams {
+        value?: string;
+    }
+}
+
+/**
+ * Language Management Routes
+ * Translated from @volo/abp.ng.language-management v0.7.2
+ */
+
+/**
+ * Default routes for language management module
+ */
+declare const LANGUAGE_MANAGEMENT_ROUTES: {
+    routes: ABP.FullRoute[];
+};
+
+/**
+ * Language Management Service
+ * Translated from @volo/abp.ng.language-management v0.7.2
+ *
+ * Provides API operations for managing languages and language texts (localization).
+ */
+
+/**
+ * Service for managing language-related API operations.
+ * Handles languages, cultures, resources, and language texts CRUD operations.
+ *
+ * @since 0.7.2
+ */
+declare class LanguageManagementService {
+    private rest;
+    constructor(rest: RestService);
+    /**
+     * Get all languages with optional pagination
+     * @param params - Optional query parameters for pagination and filtering
+     * @returns Promise with paginated language response
+     */
+    getLanguages(params?: ABP.PageQueryParams): Promise<LanguageManagement.LanguageResponse>;
+    /**
+     * Get a language by ID
+     * @param id - The language ID
+     * @returns Promise with the language
+     */
+    getLanguageById(id: string): Promise<LanguageManagement.Language>;
+    /**
+     * Create a new language
+     * @param body - The language data to create
+     * @returns Promise with the created language
+     */
+    createLanguage(body: LanguageManagement.CreateLanguageInput): Promise<LanguageManagement.Language>;
+    /**
+     * Update an existing language
+     * @param id - The language ID to update
+     * @param body - The updated language data
+     * @returns Promise with the updated language
+     */
+    updateLanguage(id: string, body: LanguageManagement.UpdateLanguageInput): Promise<LanguageManagement.Language>;
+    /**
+     * Delete a language
+     * @param id - The language ID to delete
+     * @returns Promise resolving when complete
+     */
+    deleteLanguage(id: string): Promise<void>;
+    /**
+     * Set a language as the default language
+     * @param id - The language ID to set as default
+     * @returns Promise resolving when complete
+     */
+    setAsDefaultLanguage(id: string): Promise<void>;
+    /**
+     * Get all available cultures
+     * @returns Promise with list of cultures
+     */
+    getCultures(): Promise<LanguageManagement.Culture[]>;
+    /**
+     * Get all available localization resources
+     * @returns Promise with list of resources
+     */
+    getResources(): Promise<LanguageManagement.Resource[]>;
+    /**
+     * Get language texts with pagination and filtering
+     * @param params - Query parameters including resource name, cultures, and filter options
+     * @returns Promise with paginated language text response
+     */
+    getLanguageTexts(params: LanguageManagement.LanguageTextQueryParams): Promise<LanguageManagement.LanguageTextResponse>;
+    /**
+     * Get a language text by name
+     * @param params - Parameters identifying the language text
+     * @returns Promise with the language text
+     */
+    getLanguageTextByName(params: LanguageManagement.LanguageTextRequestByNameParams): Promise<LanguageManagement.LanguageText>;
+    /**
+     * Update a language text by name
+     * @param params - Parameters including the new value
+     * @returns Promise with the updated language text
+     */
+    updateLanguageTextByName(params: LanguageManagement.LanguageTextUpdateByNameParams): Promise<LanguageManagement.LanguageText>;
+    /**
+     * Restore a language text to its default value
+     * @param params - Parameters identifying the language text
+     * @returns Promise resolving when complete
+     */
+    restoreLanguageTextByName(params: LanguageManagement.LanguageTextRequestByNameParams): Promise<void>;
+}
+
+/**
+ * Sort order type for language lists
+ */
+type SortOrder$1 = '' | 'asc' | 'desc';
+/**
+ * Result from language operations
+ * @since 0.7.2
+ */
+interface LanguageOperationResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Return type for useLanguages hook
+ * @since 0.7.2
+ */
+interface UseLanguagesReturn {
+    /** List of languages */
+    languages: LanguageManagement.Language[];
+    /** Total count of languages */
+    totalCount: number;
+    /** Available cultures for creating languages */
+    cultures: LanguageManagement.Culture[];
+    /** Currently selected language for editing */
+    selectedLanguage: LanguageManagement.Language | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Current sort key */
+    sortKey: string;
+    /** Current sort order */
+    sortOrder: SortOrder$1;
+    /** Fetch all languages with optional pagination/filtering */
+    fetchLanguages: (params?: ABP.PageQueryParams) => Promise<LanguageOperationResult>;
+    /** Fetch all available cultures */
+    fetchCultures: () => Promise<LanguageOperationResult>;
+    /** Get a language by ID and set it as selected */
+    getLanguageById: (id: string) => Promise<LanguageOperationResult>;
+    /** Create a new language */
+    createLanguage: (language: LanguageManagement.CreateLanguageInput) => Promise<LanguageOperationResult>;
+    /** Update an existing language */
+    updateLanguage: (id: string, language: LanguageManagement.UpdateLanguageInput) => Promise<LanguageOperationResult>;
+    /** Delete a language */
+    deleteLanguage: (id: string) => Promise<LanguageOperationResult>;
+    /** Set a language as default */
+    setAsDefaultLanguage: (id: string) => Promise<LanguageOperationResult>;
+    /** Set the selected language */
+    setSelectedLanguage: (language: LanguageManagement.Language | null) => void;
+    /** Set sort key */
+    setSortKey: (key: string) => void;
+    /** Set sort order */
+    setSortOrder: (order: SortOrder$1) => void;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook for managing languages
+ *
+ * This hook provides all the state and actions needed for language management.
+ * It handles fetching, creating, updating, and deleting languages.
+ *
+ * @since 0.7.2
+ *
+ * @example
+ * ```tsx
+ * function LanguagesPage() {
+ *   const {
+ *     languages,
+ *     isLoading,
+ *     fetchLanguages,
+ *     createLanguage,
+ *     deleteLanguage,
+ *   } = useLanguages();
+ *
+ *   useEffect(() => {
+ *     fetchLanguages();
+ *   }, [fetchLanguages]);
+ *
+ *   const handleCreate = async (data: LanguageManagement.CreateLanguageInput) => {
+ *     const result = await createLanguage(data);
+ *     if (result.success) {
+ *       // Handle success
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {languages.map(lang => (
+ *         <div key={lang.id}>{lang.displayName}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useLanguages(): UseLanguagesReturn;
+
+/**
+ * Sort order type for language text lists
+ */
+type SortOrder = '' | 'asc' | 'desc';
+/**
+ * Result from language text operations
+ * @since 0.7.2
+ */
+interface LanguageTextOperationResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Return type for useLanguageTexts hook
+ * @since 0.7.2
+ */
+interface UseLanguageTextsReturn {
+    /** List of language texts */
+    languageTexts: LanguageManagement.LanguageText[];
+    /** Total count of language texts */
+    totalCount: number;
+    /** Available localization resources */
+    resources: LanguageManagement.Resource[];
+    /** Currently selected language text for editing */
+    selectedLanguageText: LanguageManagement.LanguageText | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Current sort key */
+    sortKey: string;
+    /** Current sort order */
+    sortOrder: SortOrder;
+    /** Fetch language texts with filtering */
+    fetchLanguageTexts: (params: LanguageManagement.LanguageTextQueryParams) => Promise<LanguageTextOperationResult>;
+    /** Fetch all available resources */
+    fetchResources: () => Promise<LanguageTextOperationResult>;
+    /** Get a language text by name */
+    getLanguageTextByName: (params: LanguageManagement.LanguageTextRequestByNameParams) => Promise<LanguageTextOperationResult>;
+    /** Update a language text by name */
+    updateLanguageTextByName: (params: LanguageManagement.LanguageTextUpdateByNameParams) => Promise<LanguageTextOperationResult>;
+    /** Restore a language text to its default value */
+    restoreLanguageTextByName: (params: LanguageManagement.LanguageTextRequestByNameParams) => Promise<LanguageTextOperationResult>;
+    /** Set the selected language text */
+    setSelectedLanguageText: (languageText: LanguageManagement.LanguageText | null) => void;
+    /** Set sort key */
+    setSortKey: (key: string) => void;
+    /** Set sort order */
+    setSortOrder: (order: SortOrder) => void;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook for managing language texts (localization strings)
+ *
+ * This hook provides all the state and actions needed for language text management.
+ * It handles fetching, updating, and restoring language texts.
+ *
+ * @since 0.7.2
+ *
+ * @example
+ * ```tsx
+ * function LanguageTextsPage() {
+ *   const {
+ *     languageTexts,
+ *     isLoading,
+ *     fetchLanguageTexts,
+ *     updateLanguageTextByName,
+ *   } = useLanguageTexts();
+ *
+ *   useEffect(() => {
+ *     fetchLanguageTexts({
+ *       baseCultureName: 'en',
+ *       targetCultureName: 'tr',
+ *       getOnlyEmptyValues: false,
+ *     });
+ *   }, [fetchLanguageTexts]);
+ *
+ *   const handleUpdate = async (name: string, value: string) => {
+ *     const result = await updateLanguageTextByName({
+ *       resourceName: 'MyResource',
+ *       cultureName: 'tr',
+ *       name,
+ *       value,
+ *     });
+ *     if (result.success) {
+ *       // Handle success
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {languageTexts.map(text => (
+ *         <div key={text.name}>{text.name}: {text.value}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useLanguageTexts(): UseLanguageTextsReturn;
+
+/**
+ * Props for LanguagesComponent
+ * @since 0.7.2
+ */
+interface LanguagesComponentProps {
+    /** Optional callback when a language is created */
+    onLanguageCreated?: (language: LanguageManagement.Language) => void;
+    /** Optional callback when a language is updated */
+    onLanguageUpdated?: (language: LanguageManagement.Language) => void;
+    /** Optional callback when a language is deleted */
+    onLanguageDeleted?: (id: string) => void;
+}
+/**
+ * LanguagesComponent - Component for managing languages
+ *
+ * This is the React equivalent of Angular's LanguagesComponent.
+ * It displays a table of languages with CRUD operations.
+ *
+ * @since 0.7.2
+ *
+ * @example
+ * ```tsx
+ * function LanguageManagementPage() {
+ *   return (
+ *     <LanguagesComponent
+ *       onLanguageCreated={(lang) => console.log('Language created:', lang)}
+ *       onLanguageDeleted={(id) => console.log('Language deleted:', id)}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function LanguagesComponent({ onLanguageCreated, onLanguageUpdated, onLanguageDeleted, }: LanguagesComponentProps): React.ReactElement;
+
+/**
+ * Props for LanguageTextsComponent
+ * @since 0.7.2
+ */
+interface LanguageTextsComponentProps {
+    /** Optional callback when a language text is updated */
+    onLanguageTextUpdated?: (params: LanguageManagement.LanguageTextUpdateByNameParams) => void;
+    /** Optional callback when a language text is restored */
+    onLanguageTextRestored?: (params: LanguageManagement.LanguageTextRequestByNameParams) => void;
+}
+/**
+ * LanguageTextsComponent - Component for managing language texts (localization strings)
+ *
+ * This is the React equivalent of Angular's LanguageTextsComponent.
+ * It displays a table of language texts with editing capabilities.
+ *
+ * @since 0.7.2
+ *
+ * @example
+ * ```tsx
+ * function LanguageManagementPage() {
+ *   return (
+ *     <LanguageTextsComponent
+ *       onLanguageTextUpdated={(params) => console.log('Language text updated:', params)}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function LanguageTextsComponent({ onLanguageTextUpdated, onLanguageTextRestored, }: LanguageTextsComponentProps): React.ReactElement;
+
+export { LANGUAGE_MANAGEMENT_ROUTES, LanguageManagement, LanguageManagementService, type LanguageOperationResult, type LanguageTextOperationResult, LanguageTextsComponent, type LanguageTextsComponentProps, LanguagesComponent, type LanguagesComponentProps, type SortOrder$1 as SortOrder, type UseLanguageTextsReturn, type UseLanguagesReturn, useLanguageTexts, useLanguages };