smartling-api-sdk-nodejs 3.2.3 → 3.4.0

package/api/glossaries/params/entries-bulk-action-parameters.ts

@@ -0,0 +1,149 @@
+import { BaseParameters } from "../../parameters/index";
+import { ExportEntriesFilterDto } from "../dto/export-entries-filter-dto";
+import { EntryState } from "../enums/entry-state";
+import { LabelTypeDto } from "../dto/label-type-dto";
+import { DateFilterDto } from "../dto/date-filter-dto";
+import { UserFilterDto } from "../dto/user-filter-dto";
+import { PaginationDto } from "../dto/pagination-dto";
+import { EntrySortingDto } from "../dto/entry-sorting-dto";
+
+export class EntriesBulkActionParameters extends BaseParameters {
+    constructor() {
+        super();
+        this.set("filter", {});
+    }
+
+    setFilter(filter: ExportEntriesFilterDto): EntriesBulkActionParameters {
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterQuery(query: string): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.query = query;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterLocaleIds(localeIds: Array<string>): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.localeIds = localeIds;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterEntryUids(entryUids: Array<string>): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.entryUids = entryUids;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterEntryState(entryState: EntryState): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.entryState = entryState;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterMissingTranslationLocaleId(localeId: string): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.missingTranslationLocaleId = localeId;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterPresentTranslationLocaleId(localeId: string): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.presentTranslationLocaleId = localeId;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterDntLocaleId(localeId: string): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.dntLocaleId = localeId;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterReturnFallbackTranslations(returnFallback: boolean): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.returnFallbackTranslations = returnFallback;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterLabels(labels: LabelTypeDto): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.labels = labels;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterDntTermSet(dntTermSet: boolean): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.dntTermSet = dntTermSet;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterCreated(created: DateFilterDto): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.created = created;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterLastModified(lastModified: DateFilterDto): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.lastModified = lastModified;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterCreatedBy(createdBy: UserFilterDto): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.createdBy = createdBy;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterLastModifiedBy(lastModifiedBy: UserFilterDto): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.lastModifiedBy = lastModifiedBy;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterPaging(paging: PaginationDto): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.paging = paging;
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterSorting(sorting: EntrySortingDto): EntriesBulkActionParameters {
+        const filter = this.parameters.filter || {};
+        filter.sorting = sorting;
+        this.set("filter", filter);
+
+        return this;
+    }
+}

package/api/glossaries/params/entries-bulk-labels-parameters.ts

@@ -0,0 +1,123 @@
+import { BaseParameters } from "../../parameters/index";
+import { ExportEntriesFilterDto } from "../dto/export-entries-filter-dto";
+import { EntryState } from "../enums/entry-state";
+import { LabelTypeDto } from "../dto/label-type-dto";
+import { DateFilterDto } from "../dto/date-filter-dto";
+import { UserFilterDto } from "../dto/user-filter-dto";
+import { PaginationDto } from "../dto/pagination-dto";
+import { EntrySortingDto } from "../dto/entry-sorting-dto";
+
+export class EntriesBulkLabelsParameters extends BaseParameters {
+    constructor() {
+        super();
+        this.set("filter", {});
+    }
+
+    setFilter(filter: ExportEntriesFilterDto): EntriesBulkLabelsParameters {
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setFilterQuery(query: string): EntriesBulkLabelsParameters {
+        this.parameters.filter.query = query;
+
+        return this;
+    }
+
+    setFilterLocaleIds(localeIds: Array<string>): EntriesBulkLabelsParameters {
+        this.parameters.filter.localeIds = localeIds;
+
+        return this;
+    }
+
+    setFilterEntryUids(entryUids: Array<string>): EntriesBulkLabelsParameters {
+        this.parameters.filter.entryUids = entryUids;
+
+        return this;
+    }
+
+    setFilterEntryState(entryState: EntryState): EntriesBulkLabelsParameters {
+        this.parameters.filter.entryState = entryState;
+
+        return this;
+    }
+
+    setFilterMissingTranslationLocaleId(localeId: string): EntriesBulkLabelsParameters {
+        this.parameters.filter.missingTranslationLocaleId = localeId;
+
+        return this;
+    }
+
+    setFilterPresentTranslationLocaleId(localeId: string): EntriesBulkLabelsParameters {
+        this.parameters.filter.presentTranslationLocaleId = localeId;
+
+        return this;
+    }
+
+    setFilterDntLocaleId(localeId: string): EntriesBulkLabelsParameters {
+        this.parameters.filter.dntLocaleId = localeId;
+
+        return this;
+    }
+
+    setFilterReturnFallbackTranslations(returnFallback: boolean): EntriesBulkLabelsParameters {
+        this.parameters.filter.returnFallbackTranslations = returnFallback;
+
+        return this;
+    }
+
+    setFilterLabels(labels: LabelTypeDto): EntriesBulkLabelsParameters {
+        this.parameters.filter.labels = labels;
+
+        return this;
+    }
+
+    setFilterDntTermSet(dntTermSet: boolean): EntriesBulkLabelsParameters {
+        this.parameters.filter.dntTermSet = dntTermSet;
+
+        return this;
+    }
+
+    setFilterCreated(created: DateFilterDto): EntriesBulkLabelsParameters {
+        this.parameters.filter.created = created;
+
+        return this;
+    }
+
+    setFilterLastModified(lastModified: DateFilterDto): EntriesBulkLabelsParameters {
+        this.parameters.filter.lastModified = lastModified;
+
+        return this;
+    }
+
+    setFilterCreatedBy(createdBy: UserFilterDto): EntriesBulkLabelsParameters {
+        this.parameters.filter.createdBy = createdBy;
+
+        return this;
+    }
+
+    setFilterLastModifiedBy(lastModifiedBy: UserFilterDto): EntriesBulkLabelsParameters {
+        this.parameters.filter.lastModifiedBy = lastModifiedBy;
+
+        return this;
+    }
+
+    setFilterPaging(paging: PaginationDto): EntriesBulkLabelsParameters {
+        this.parameters.filter.paging = paging;
+
+        return this;
+    }
+
+    setFilterSorting(sorting: EntrySortingDto): EntriesBulkLabelsParameters {
+        this.parameters.filter.sorting = sorting;
+
+        return this;
+    }
+
+    setLabelUids(labelUids: Array<string>): EntriesBulkLabelsParameters {
+        this.set("labelUids", labelUids);
+
+        return this;
+    }
+}

package/api/glossaries/params/export-entries-parameters.ts

@@ -47,114 +47,82 @@ export class ExportEntriesParameters extends BaseParameters {
     }
 
     setFilterQuery(query: string): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.query = query;
-        this.set("filter", filter);
+        this.parameters.filter.query = query;
         return this;
     }
 
     setFilterLocaleIds(localeIds: Array<string>): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.localeIds = localeIds;
-        this.set("filter", filter);
+        this.parameters.filter.localeIds = localeIds;
         return this;
     }
 
     setFilterEntryUids(entryUids: Array<string>): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.entryUids = entryUids;
-        this.set("filter", filter);
+        this.parameters.filter.entryUids = entryUids;
         return this;
     }
 
     setFilterEntryState(entryState: EntryState): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.entryState = entryState;
-        this.set("filter", filter);
+        this.parameters.filter.entryState = entryState;
         return this;
     }
 
     setFilterMissingTranslationLocaleId(localeId: string): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.missingTranslationLocaleId = localeId;
-        this.set("filter", filter);
+        this.parameters.filter.missingTranslationLocaleId = localeId;
         return this;
     }
 
     setFilterPresentTranslationLocaleId(localeId: string): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.presentTranslationLocaleId = localeId;
-        this.set("filter", filter);
+        this.parameters.filter.presentTranslationLocaleId = localeId;
         return this;
     }
 
     setFilterDntLocaleId(localeId: string): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.dntLocaleId = localeId;
-        this.set("filter", filter);
+        this.parameters.filter.dntLocaleId = localeId;
         return this;
     }
 
     setFilterReturnFallbackTranslations(returnFallback: boolean): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.returnFallbackTranslations = returnFallback;
-        this.set("filter", filter);
+        this.parameters.filter.returnFallbackTranslations = returnFallback;
         return this;
     }
 
     setFilterLabels(labels: LabelTypeDto): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.labels = labels;
-        this.set("filter", filter);
+        this.parameters.filter.labels = labels;
         return this;
     }
 
     setFilterDntTermSet(dntTermSet: boolean): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.dntTermSet = dntTermSet;
-        this.set("filter", filter);
+        this.parameters.filter.dntTermSet = dntTermSet;
         return this;
     }
 
     setFilterCreated(created: DateFilterDto): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.created = created;
-        this.set("filter", filter);
+        this.parameters.filter.created = created;
         return this;
     }
 
     setFilterLastModified(lastModified: DateFilterDto): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.lastModified = lastModified;
-        this.set("filter", filter);
+        this.parameters.filter.lastModified = lastModified;
         return this;
     }
 
     setFilterCreatedBy(createdBy: UserFilterDto): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.createdBy = createdBy;
-        this.set("filter", filter);
+        this.parameters.filter.createdBy = createdBy;
         return this;
     }
 
     setFilterLastModifiedBy(lastModifiedBy: UserFilterDto): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.lastModifiedBy = lastModifiedBy;
-        this.set("filter", filter);
+        this.parameters.filter.lastModifiedBy = lastModifiedBy;
         return this;
     }
 
     setFilterPaging(paging: PaginationDto): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.paging = paging;
-        this.set("filter", filter);
+        this.parameters.filter.paging = paging;
         return this;
     }
 
     setFilterSorting(sorting: EntrySortingDto): ExportEntriesParameters {
-        const filter = this.parameters.filter || {};
-        filter.sorting = sorting;
-        this.set("filter", filter);
+        this.parameters.filter.sorting = sorting;
         return this;
     }
 }

package/api/glossaries/params/initialize-import-parameters.ts

@@ -0,0 +1,42 @@
+import * as fs from "fs";
+import string2fileStream from "string-to-file-stream";
+import { BaseParameters } from "../../parameters/index";
+import { ImportFileMediaType } from "../enums/import-file-media-type";
+
+export class InitializeImportParameters extends BaseParameters {
+    setArchiveMode(archiveMode: boolean): InitializeImportParameters {
+        this.set("archiveMode", archiveMode);
+
+        return this;
+    }
+
+    setImportFileFromLocalFilePath(filePath: string): InitializeImportParameters {
+        this.set("importFile", fs.createReadStream(fs.realpathSync(filePath)));
+
+        return this;
+    }
+
+    setImportFileContent(fileContent: string): InitializeImportParameters {
+        this.set("importFile", string2fileStream(fileContent));
+
+        return this;
+    }
+
+    setImportFileContentFromBuffer(fileContent: Buffer): InitializeImportParameters {
+        this.set("importFile", fileContent);
+
+        return this;
+    }
+
+    setImportFileName(importFileName: string): InitializeImportParameters {
+        this.set("importFileName", importFileName);
+
+        return this;
+    }
+
+    setImportFileMediaType(importFileMediaType: ImportFileMediaType): InitializeImportParameters {
+        this.set("importFileMediaType", importFileMediaType);
+
+        return this;
+    }
+}

package/api/glossaries/params/search-glossary-counts-parameters.ts

@@ -0,0 +1,41 @@
+import { BaseParameters } from "../../parameters/index";
+import { PaginationDto } from "../dto/pagination-dto";
+import { SortingDto } from "../dto/sorting-dto";
+
+export class SearchGlossaryCountsParameters extends BaseParameters {
+    setQuery(query: string): SearchGlossaryCountsParameters {
+        this.set("query", query);
+
+        return this;
+    }
+
+    setGlossaryState(glossaryState: "ACTIVE" | "ARCHIVED" | "BOTH"): SearchGlossaryCountsParameters {
+        this.set("glossaryState", glossaryState);
+
+        return this;
+    }
+
+    setTargetLocaleId(targetLocaleId: string): SearchGlossaryCountsParameters {
+        this.set("targetLocaleId", targetLocaleId);
+
+        return this;
+    }
+
+    setGlossaryUids(glossaryUids: Array<string>): SearchGlossaryCountsParameters {
+        this.set("glossaryUids", glossaryUids);
+
+        return this;
+    }
+
+    setPaging(paging: PaginationDto): SearchGlossaryCountsParameters {
+        this.set("paging", paging);
+
+        return this;
+    }
+
+    setSorting(sorting: SortingDto): SearchGlossaryCountsParameters {
+        this.set("sorting", sorting);
+
+        return this;
+    }
+}

package/api/glossaries/params/search-glossary-entries-parameters.ts

@@ -0,0 +1,105 @@
+import { BaseParameters } from "../../parameters/index";
+import { EntryState } from "../enums/entry-state";
+import { LabelTypeDto } from "../dto/label-type-dto";
+import { DateFilterDto } from "../dto/date-filter-dto";
+import { UserFilterDto } from "../dto/user-filter-dto";
+import { PaginationDto } from "../dto/pagination-dto";
+import { EntrySortingDto } from "../dto/entry-sorting-dto";
+
+export class SearchGlossaryEntriesParameters extends BaseParameters {
+    setQuery(query: string): SearchGlossaryEntriesParameters {
+        this.set("query", query);
+
+        return this;
+    }
+
+    setLocaleIds(localeIds: Array<string>): SearchGlossaryEntriesParameters {
+        this.set("localeIds", localeIds);
+
+        return this;
+    }
+
+    setEntryUids(entryUids: Array<string>): SearchGlossaryEntriesParameters {
+        this.set("entryUids", entryUids);
+
+        return this;
+    }
+
+    setEntryState(entryState: EntryState): SearchGlossaryEntriesParameters {
+        this.set("entryState", entryState);
+
+        return this;
+    }
+
+    setMissingTranslationLocaleId(localeId: string): SearchGlossaryEntriesParameters {
+        this.set("missingTranslationLocaleId", localeId);
+
+        return this;
+    }
+
+    setPresentTranslationLocaleId(localeId: string): SearchGlossaryEntriesParameters {
+        this.set("presentTranslationLocaleId", localeId);
+
+        return this;
+    }
+
+    setDntLocaleId(localeId: string): SearchGlossaryEntriesParameters {
+        this.set("dntLocaleId", localeId);
+
+        return this;
+    }
+
+    setReturnFallbackTranslations(returnFallback: boolean): SearchGlossaryEntriesParameters {
+        this.set("returnFallbackTranslations", returnFallback);
+
+        return this;
+    }
+
+    setLabels(labels: LabelTypeDto): SearchGlossaryEntriesParameters {
+        this.set("labels", labels);
+
+        return this;
+    }
+
+    setDntTermSet(dntTermSet: boolean): SearchGlossaryEntriesParameters {
+        this.set("dntTermSet", dntTermSet);
+
+        return this;
+    }
+
+    setCreated(created: DateFilterDto): SearchGlossaryEntriesParameters {
+        this.set("created", created);
+
+        return this;
+    }
+
+    setLastModified(lastModified: DateFilterDto): SearchGlossaryEntriesParameters {
+        this.set("lastModified", lastModified);
+
+        return this;
+    }
+
+    setCreatedBy(createdBy: UserFilterDto): SearchGlossaryEntriesParameters {
+        this.set("createdBy", createdBy);
+
+        return this;
+    }
+
+    setLastModifiedBy(lastModifiedBy: UserFilterDto): SearchGlossaryEntriesParameters {
+        this.set("lastModifiedBy", lastModifiedBy);
+
+        return this;
+    }
+
+    setPaging(paging: PaginationDto): SearchGlossaryEntriesParameters {
+        this.set("paging", paging);
+
+        return this;
+    }
+
+    setSorting(sorting: EntrySortingDto): SearchGlossaryEntriesParameters {
+        this.set("sorting", sorting);
+
+        return this;
+    }
+}

package/api/translation-memory/dto/async-action-result-dto.ts

@@ -0,0 +1,12 @@
+import { AsyncActionStatus } from "./async-action-status";
+
+interface AsyncActionResultDto {
+    actionUid: string;
+    totalCount: number;
+    processedCount: number;
+    errorCount: number;
+    executionComplete: boolean;
+    actionStatus: AsyncActionStatus;
+}
+
+export { AsyncActionResultDto };

package/api/translation-memory/dto/async-action-status.ts

@@ -0,0 +1,8 @@
+export enum AsyncActionStatus {
+    QUEUEING = "QUEUEING",
+    EXECUTING = "EXECUTING",
+    SUCCESS = "SUCCESS",
+    FAILURE = "FAILURE",
+    CANCELED = "CANCELED",
+    STOPPED = "STOPPED"
+}

package/api/translation-memory/dto/create-string-search-result-dto.ts

@@ -0,0 +1,16 @@
+import { DuplicateStringDto } from "./duplicate-string-dto";
+
+interface CreateStringSearchResultDto {
+    searchUid: string;
+    stringCount: number | null;
+    wordCount: number | null;
+    duplicateStrings: Array<DuplicateStringDto> | null;
+    duplicateSearch: boolean | null;
+    // UID of the async action tracking search indexing, only present if indexing continues in
+    // the background - distinct from AsyncActionResultDto.actionUid (a bulk operation's own
+    // tracking UID, always present once that operation has started).
+    actionUid: string | null;
+    offlineReportUid: string | null;
+}
+
+export { CreateStringSearchResultDto };

package/api/translation-memory/dto/duplicate-string-dto.ts

@@ -0,0 +1,9 @@
+interface DuplicateStringDto {
+    duplicateKey: string;
+    count: number;
+    srcText: string;
+    srcLocale: string;
+    translationLocale: string;
+}
+
+export { DuplicateStringDto };

package/api/translation-memory/dto/locale-summary-dto.ts

@@ -0,0 +1,10 @@
+import { TmLocaleDto } from "./tm-locale-dto";
+
+interface LocaleSummaryDto {
+    translationLocaleId: string;
+    translationLocale: TmLocaleDto;
+    stringCount: number;
+    wordCount: number;
+}
+
+export { LocaleSummaryDto };

package/api/translation-memory/dto/strings-export-async-action-result-dto.ts

@@ -0,0 +1,8 @@
+import { AsyncActionResultDto } from "./async-action-result-dto";
+
+interface StringsExportAsyncActionResultDto extends AsyncActionResultDto {
+    tmxDownloadKey: string | null;
+    expired: boolean;
+}
+
+export { StringsExportAsyncActionResultDto };

package/api/translation-memory/dto/tm-dto.ts

@@ -0,0 +1,23 @@
+import { UserDto } from "./user-dto";
+import { TmLocaleDto } from "./tm-locale-dto";
+import { LocaleSummaryDto } from "./locale-summary-dto";
+import { TranslationQualityType } from "../params/translation-quality-type";
+
+interface TmDto {
+    // Nullable per the real schema (TM.tmUid: ID, no "!"), but in practice always populated for
+    // a successful createTm/updateTm/deleteTm/searchTms result - it's the TM's own identifier.
+    tmUid: string | null;
+    name: string;
+    description: string | null;
+    sourceLocaleId: string;
+    sourceLocale: TmLocaleDto;
+    creator: UserDto;
+    created: Date;
+    lastModifier: UserDto;
+    lastModified: Date;
+    localeSummary: Array<LocaleSummaryDto> | null;
+    translationQuality: TranslationQualityType;
+    managedWordsEnabled: boolean;
+}
+
+export { TmDto };