[pull] master from crowdin:master

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crowdin/crowdin-api-client",
-    "version": "1.55.4",
+    "version": "1.56.0",
     "description": "JavaScript library for Crowdin API",
     "main": "out/index.js",
     "types": "out/index.d.ts",

src/ai/index.ts

@@ -1368,8 +1368,8 @@ export namespace AiModel {
         enabledProjectIds: number[];
         config:
             | AiModel.AiPromptConfigBasicPreTranslate
-            | AiModel.AiPromptConfigBasicAssistAction
             | AiModel.AiPromptConfigBasicAligmentAction
+            | AiModel.AiPromptConfigBasicQaCheckAction
             | AiModel.AiPromptConfigAdvanced
             | AiModel.AiPromptConfigExternal;
         promptPreview: string;
@@ -1407,38 +1407,39 @@ export namespace AiModel {
         fileContent?: boolean;
         fileContext?: boolean;
         screenshots?: boolean;
+        projectContext?: boolean;
+        /**
+         * @deprecated Use `projectContext` instead.
+         */
         publicProjectDescription?: boolean;
         siblingsStrings?: boolean;
+        organizationContext?: boolean;
     }
 
-    export interface AiPromptConfigBasicAssistAction {
+    export interface AiPromptConfigBasicAligmentAction {
         mode: 'basic';
+        customPlaceholders?: string[];
+        projectContext?: boolean;
         /**
-         * @deprecated
-         */
-        companyDescription?: string;
-        /**
-         * @deprecated
-         */
-        projectDescription?: string;
-        /**
-         * @deprecated
+         * @deprecated Use `projectContext` instead.
          */
-        audienceDescription?: string;
-        otherLanguageTranslations?: AiModel.AiPromptConfigBasicOtherLanguageTranslations;
-        glossaryTerms?: boolean;
-        tmSuggestions?: boolean;
-        fileContext?: boolean;
-        screenshots?: boolean;
         publicProjectDescription?: boolean;
-        siblingsStrings?: boolean;
-        filteredStrings?: boolean;
+        organizationContext?: boolean;
     }
 
-    export interface AiPromptConfigBasicAligmentAction {
+    export interface AiPromptConfigBasicQaCheckAction {
         mode: 'basic';
-        customPlaceholders?: string[];
+        evaluationSteps: string[];
+        glossaryTerms?: boolean;
+        tmSuggestions?: boolean;
+        fileContext?: boolean;
+        screenshots?: boolean;
+        projectContext?: boolean;
+        /**
+         * @deprecated Use `projectContext` instead.
+         */
         publicProjectDescription?: boolean;
+        organizationContext?: boolean;
     }
 
     export interface AiPromptConfigAdvanced {
@@ -1464,17 +1465,17 @@ export namespace AiModel {
         enabledProjectIds?: number[];
         config:
             | AiModel.AiPromptConfigBasicPreTranslate
-            | AiModel.AiPromptConfigBasicAssistAction
             | AiModel.AiPromptConfigBasicAligmentAction
+            | AiModel.AiPromptConfigBasicQaCheckAction
             | AiModel.AiPromptConfigAdvanced
             | AiPromptConfigExternal;
     }
 
     export interface GenerateAiPromptCompletionRequest {
         resources:
             | AiModel.AiPromptResourceWithPreTranslate
-            | AiModel.AiPromptResourceWithAssist
             | AiModel.AiPromptResourceWithAlignment
+            | AiModel.AiPromptResourceWithQaCheck
             | AiModel.AiPromptResourceWithCustom;
         tools?: {
             tool: {
@@ -1509,12 +1510,11 @@ export namespace AiModel {
         overridePromptValues?: OverridePromptValues;
     }
 
-    export interface AiPromptResourceWithAssist {
+    export interface AiPromptResourceWithQaCheck {
         projectId: number;
         sourceLanguageId?: string;
         targetLanguageId?: string;
         stringIds?: number[];
-        filteredStringsIds?: number[];
         overridePromptValues?: OverridePromptValues;
     }
 
@@ -1582,7 +1582,7 @@ export namespace AiModel {
     }
 
     export interface AiProviderConfigActionRule {
-        action?: 'pre_translate' | 'assist';
+        action?: 'pre_translate' | 'alignment' | 'qa_check';
         availableAiModelIds?: string[];
     }
 
@@ -1704,6 +1704,7 @@ export namespace AiModel {
         parserVersion?: number;
         tmIds?: number[];
         glossaryIds?: number[];
+        styleGuideIds?: number[];
         aiPromptId?: number;
         aiProviderId?: number;
         aiModelId?: string;
@@ -1733,6 +1734,7 @@ export namespace AiModel {
         sourceLanguageId?: string;
         tmIds?: number[];
         glossaryIds?: number[];
+        styleGuideIds?: number[];
         aiPromptId?: number;
         aiProviderId?: number;
         aiModelId?: string;
@@ -1747,7 +1749,7 @@ export namespace AiModel {
     }
     /* ai Translate Strings Section END*/
 
-    export type Action = 'pre_translate' | 'assist';
+    export type Action = 'pre_translate' | 'alignment' | 'qa_check';
     export type ProviderType =
         | 'open_ai'
         | 'azure_open_ai'

src/glossaries/index.ts

@@ -394,6 +394,39 @@ export namespace GlossariesModel {
     export interface ExportGlossaryRequest {
         format?: GlossaryFormat;
         exportFields?: ExportField[];
+        exportType?: ExportType;
+        text?: string;
+        caseSensitive?: boolean;
+        searchStrict?: boolean;
+        searchFullMatch?: boolean;
+        statuses?: TermStatus[];
+        partsOfSpeech?: TermPartOfSpeech[];
+        types?: TermType[];
+        genders?: TermGender[];
+        authorIds?: number[];
+        languageIds?: string[];
+        dateFrom?: string;
+        dateTo?: string;
+        /**
+         * @deprecated use `statuses` instead
+         */
+        status?: TermStatus;
+        /**
+         * @deprecated use `partsOfSpeech` instead
+         */
+        partOfSpeech?: TermPartOfSpeech;
+        /**
+         * @deprecated use `types` instead
+         */
+        type?: TermType;
+        /**
+         * @deprecated use `genders` instead
+         */
+        gender?: TermGender;
+        /**
+         * @deprecated use `authorIds` instead
+         */
+        authorId?: number;
     }
 
     export interface GlossaryExportStatusAttribute {
@@ -486,6 +519,32 @@ export namespace GlossariesModel {
 
     export type GlossaryFormat = 'tbx' | 'tbx_v3' | 'csv' | 'xlsx';
 
+    export type ExportType = 'concepts' | 'terms';
+
+    export type TermStatus = 'PREFERRED' | 'ADMITTED' | 'NOT_RECOMMENDED' | 'OBSOLETE' | 'DRAFT';
+
+    export type TermPartOfSpeech =
+        | 'NOUN'
+        | 'VERB'
+        | 'ADJ'
+        | 'PRON'
+        | 'PROPN'
+        | 'DET'
+        | 'ADV'
+        | 'ADP'
+        | 'CCONJ'
+        | 'SCONJ'
+        | 'NUM'
+        | 'INTJ'
+        | 'AUX'
+        | 'PRT'
+        | 'SYM'
+        | 'X';
+
+    export type TermType = 'FULL_FORM' | 'ACRONYM' | 'ABBREVIATION' | 'SHORT_FORM' | 'PHRASE' | 'VARIANT';
+
+    export type TermGender = 'MASCULINE' | 'FEMININE' | 'NEUTER' | 'COMMON' | 'OTHER';
+
     export interface GlossaryFileScheme {
         [key: string]: number;
     }

src/translations/index.ts

@@ -317,36 +317,56 @@ export namespace TranslationsModel {
         languageIds: string[];
         fileIds: number[];
         method?: Method;
+        priority?: Priority;
         engineId?: number;
         aiPromptId?: number;
         autoApproveOption?: AutoApproveOption;
         duplicateTranslations?: boolean;
         skipApprovedTranslations?: boolean;
+        /**
+         * @deprecated Use {@link scope} instead
+         */
         translateUntranslatedOnly?: boolean;
+        scope?: Scope;
+        translationModifiedBefore?: string;
+        replaceTranslationsOption?: ReplaceTranslationsOption;
+        resetApprovalStatus?: boolean;
         translateWithPerfectMatchOnly?: boolean;
         fallbackLanguages?: {
             languageId?: string[];
         };
         labelIds?: number[];
         excludeLabelIds?: number[];
+        sourceLanguageId?: string;
+        customInstruction?: string;
     }
 
     export interface PreTranslateStringsRequest {
         languageIds: string[];
         branchIds?: number[];
         method?: Method;
+        priority?: Priority;
         engineId?: number;
         aiPromptId?: number;
         autoApproveOption?: AutoApproveOption;
         duplicateTranslations?: boolean;
         skipApprovedTranslations?: boolean;
+        /**
+         * @deprecated Use {@link scope} instead
+         */
         translateUntranslatedOnly?: boolean;
+        scope?: Scope;
+        translationModifiedBefore?: string;
+        replaceTranslationsOption?: ReplaceTranslationsOption;
+        resetApprovalStatus?: boolean;
         translateWithPerfectMatchOnly?: boolean;
         fallbackLanguages?: {
             languageId: string[];
         };
         labelIds?: number[];
         excludeLabelIds?: number[];
+        sourceLanguageId?: string;
+        customInstruction?: string;
     }
 
     export interface BuildProjectDirectoryTranslationRequest {
@@ -407,7 +427,16 @@ export namespace TranslationsModel {
 
     export type Method = 'tm' | 'mt' | 'ai';
 
-    export type AutoApproveOption = 'all' | 'exceptAutoSubstituted' | 'perfectMatchOnly' | 'none';
+    export type AutoApproveOption =
+        | 'all'
+        | 'exceptAutoSubstituted'
+        | 'perfectMatchOnly'
+        | 'perfectMatchApprovedOnly'
+        | 'none';
+
+    export type Scope = 'untranslated' | 'translated' | 'all';
+
+    export type ReplaceTranslationsOption = 'none' | 'autoTranslated' | 'all';
 
     export type Priority = 'low' | 'normal' | 'high';
 

tests/ai/api.test.ts

@@ -38,7 +38,6 @@ describe('AI API', () => {
             projectId,
             targetLanguageId: 'uk',
             stringIds: [1],
-            filteredStringsIds: [1],
             overridePromptValues: {
                 sourceLanguage: 'English',
                 targetLanguage: 'Ukrainian',

tests/glossaries/api.test.ts

@@ -14,6 +14,7 @@ describe('Glossaries API', () => {
     const glossaryFormat = 'csv';
     const glossaryLink = 'test.com';
     const exportId = '1111';
+    const exportIdWithFilters = '3333';
     const importId = '2222';
     const storageId = 1232131;
     const termId = 5555;
@@ -124,6 +125,29 @@ describe('Glossaries API', () => {
                     identifier: exportId,
                 },
             })
+            .post(
+                `/glossaries/${glossaryId}/exports`,
+                {
+                    format: glossaryFormat,
+                    exportType: 'terms',
+                    statuses: ['PREFERRED', 'ADMITTED'],
+                    partsOfSpeech: ['NOUN', 'VERB'],
+                    types: ['ACRONYM'],
+                    genders: ['MASCULINE'],
+                    authorIds: [1, 2],
+                    languageIds: ['uk', 'de'],
+                },
+                {
+                    reqheaders: {
+                        Authorization: `Bearer ${api.token}`,
+                    },
+                },
+            )
+            .reply(200, {
+                data: {
+                    identifier: exportIdWithFilters,
+                },
+            })
             .get(`/glossaries/${glossaryId}/exports/${exportId}/download`, undefined, {
                 reqheaders: {
                     Authorization: `Bearer ${api.token}`,
@@ -389,6 +413,20 @@ describe('Glossaries API', () => {
         expect(exportStatus.data.identifier).toBe(exportId);
     });
 
+    it('Export glossary with filters', async () => {
+        const exportStatus = await api.exportGlossary(glossaryId, {
+            format: glossaryFormat,
+            exportType: 'terms',
+            statuses: ['PREFERRED', 'ADMITTED'],
+            partsOfSpeech: ['NOUN', 'VERB'],
+            types: ['ACRONYM'],
+            genders: ['MASCULINE'],
+            authorIds: [1, 2],
+            languageIds: ['uk', 'de'],
+        });
+        expect(exportStatus.data.identifier).toBe(exportIdWithFilters);
+    });
+
     it('Download glossary', async () => {
         const link = await api.downloadGlossary(glossaryId, exportId);
         expect(link.data.url).toBe(glossaryLink);