smartling-api-sdk-nodejs 3.2.2 → 3.3.0

package/built/api/glossaries/dto/custom-field-value-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-field-value-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/custom-field-value-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/entry-request-translation-status-dto.d.ts

@@ -0,0 +1,6 @@
+import { TranslationRequestStatusDto } from "./translation-request-status-dto";
+export interface EntryRequestTranslationStatusDto extends TranslationRequestStatusDto {
+    projectId: string;
+    hashCode: string;
+    jobUid: string;
+}

package/built/api/glossaries/dto/entry-request-translation-status-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=entry-request-translation-status-dto.js.map

package/built/api/glossaries/dto/entry-request-translation-status-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-request-translation-status-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/entry-request-translation-status-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/glossary-entries-count-dto.d.ts

@@ -0,0 +1,5 @@
+export interface GlossaryEntriesCountDto {
+    glossaryUid: string;
+    entriesCount: number;
+    blocklistsCount: number;
+}

package/built/api/glossaries/dto/glossary-entries-count-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=glossary-entries-count-dto.js.map

package/built/api/glossaries/dto/glossary-entries-count-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glossary-entries-count-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/glossary-entries-count-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/glossary-entry-dto.d.ts

@@ -0,0 +1,22 @@
+import { PartOfSpeech } from "../enums/part-of-speech";
+import { SuggestionStatus } from "../enums/suggestion-status";
+import { GlossaryTranslationDto } from "./translation-dto";
+import { CustomFieldValueDto } from "./custom-field-value-dto";
+import { EntryRequestTranslationStatusDto } from "./entry-request-translation-status-dto";
+export interface GlossaryEntryDto {
+    entryUid: string;
+    glossaryUid: string;
+    definition: string;
+    partOfSpeech?: PartOfSpeech;
+    labelUids: Array<string>;
+    translations: Array<GlossaryTranslationDto>;
+    customFieldValues: Array<CustomFieldValueDto>;
+    archived: boolean;
+    createdByUserUid: string;
+    modifiedByUserUid: string;
+    createdDate: Date;
+    modifiedDate: Date;
+    requestTranslationStatuses?: Record<string, EntryRequestTranslationStatusDto>;
+    mtOptimizedLabel?: string;
+    suggestionStatus?: SuggestionStatus;
+}

package/built/api/glossaries/dto/glossary-entry-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=glossary-entry-dto.js.map

package/built/api/glossaries/dto/glossary-entry-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glossary-entry-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/glossary-entry-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/glossary-import-result-dto.d.ts

@@ -0,0 +1,10 @@
+import { GlossaryImportStatusDto } from "./glossary-import-status-dto";
+import { ImportEntryChangesDto } from "./import-entry-changes-dto";
+import { ImportEntryTranslationChangesDto } from "./import-entry-translation-changes-dto";
+import { ImportWarningDto } from "./import-warning-dto";
+export interface GlossaryImportResultDto {
+    glossaryImport: GlossaryImportStatusDto;
+    entryChanges: ImportEntryChangesDto;
+    translationChanges: Array<ImportEntryTranslationChangesDto>;
+    warnings: Array<ImportWarningDto>;
+}

package/built/api/glossaries/dto/glossary-import-result-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=glossary-import-result-dto.js.map

package/built/api/glossaries/dto/glossary-import-result-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glossary-import-result-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/glossary-import-result-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/glossary-import-status-dto.d.ts

@@ -0,0 +1,6 @@
+import { ImportStatus } from "../enums/import-status";
+export interface GlossaryImportStatusDto {
+    glossaryUid: string;
+    importUid: string;
+    importStatus: ImportStatus;
+}

package/built/api/glossaries/dto/glossary-import-status-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=glossary-import-status-dto.js.map

package/built/api/glossaries/dto/glossary-import-status-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glossary-import-status-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/glossary-import-status-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/glossary-uids-dto.d.ts

@@ -0,0 +1,3 @@
+export interface GlossaryUidsDto {
+    glossaryUids: Array<string>;
+}

package/built/api/glossaries/dto/glossary-uids-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=glossary-uids-dto.js.map

package/built/api/glossaries/dto/glossary-uids-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glossary-uids-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/glossary-uids-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/import-entry-changes-dto.d.ts

@@ -0,0 +1,6 @@
+export interface ImportEntryChangesDto {
+    newEntries: number;
+    existingEntryUpdates: number;
+    notMatchedEntries: number;
+    entriesToArchive: number;
+}

package/built/api/glossaries/dto/import-entry-changes-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=import-entry-changes-dto.js.map

package/built/api/glossaries/dto/import-entry-changes-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-entry-changes-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/import-entry-changes-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/import-entry-translation-changes-dto.d.ts

@@ -0,0 +1,6 @@
+export interface ImportEntryTranslationChangesDto {
+    localeId: string;
+    newTranslations: number;
+    updatedTranslations: number;
+    translationsToRemove: number;
+}

package/built/api/glossaries/dto/import-entry-translation-changes-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=import-entry-translation-changes-dto.js.map

package/built/api/glossaries/dto/import-entry-translation-changes-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-entry-translation-changes-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/import-entry-translation-changes-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/import-warning-dto.d.ts

@@ -0,0 +1,4 @@
+export interface ImportWarningDto {
+    key: string;
+    message: string;
+}

package/built/api/glossaries/dto/import-warning-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=import-warning-dto.js.map

package/built/api/glossaries/dto/import-warning-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-warning-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/import-warning-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/label-dto.d.ts

@@ -0,0 +1,4 @@
+export interface LabelDto {
+    labelUid: string;
+    labelText: string;
+}

package/built/api/glossaries/dto/label-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=label-dto.js.map

package/built/api/glossaries/dto/label-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"label-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/label-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/locale-workflow-dto.d.ts

@@ -0,0 +1,4 @@
+export interface GlossaryLocaleWorkflowDto {
+    localeId: string;
+    workflowUid: string;
+}

package/built/api/glossaries/dto/locale-workflow-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=locale-workflow-dto.js.map

package/built/api/glossaries/dto/locale-workflow-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-workflow-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/locale-workflow-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/operation-dto.d.ts

@@ -0,0 +1,3 @@
+export interface OperationDto {
+    operationUid: string;
+}

package/built/api/glossaries/dto/operation-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=operation-dto.js.map

package/built/api/glossaries/dto/operation-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/operation-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/translation-dto.d.ts

@@ -0,0 +1,19 @@
+import { CustomFieldValueDto } from "./custom-field-value-dto";
+import { TranslationRequestStatusDto } from "./translation-request-status-dto";
+export interface GlossaryTranslationDto {
+    localeId: string;
+    fallbackLocaleId?: string;
+    term: string;
+    notes?: string;
+    caseSensitive?: boolean;
+    exactMatch?: boolean;
+    doNotTranslate?: boolean;
+    disabled?: boolean;
+    variants?: Array<string>;
+    customFieldValues?: Array<CustomFieldValueDto>;
+    requestTranslationStatus?: TranslationRequestStatusDto;
+    createdByUserUid?: string;
+    modifiedByUserUid?: string;
+    createdDate?: Date;
+    modifiedDate?: Date;
+}

package/built/api/glossaries/dto/translation-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=translation-dto.js.map

package/built/api/glossaries/dto/translation-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/translation-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/dto/translation-request-status-dto.d.ts

@@ -0,0 +1,5 @@
+export interface TranslationRequestStatusDto {
+    localeId: string;
+    requestDateTime: Date;
+    requestUserUid: string;
+}

package/built/api/glossaries/dto/translation-request-status-dto.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=translation-request-status-dto.js.map

package/built/api/glossaries/dto/translation-request-status-dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-request-status-dto.js","sourceRoot":"","sources":["../../../../api/glossaries/dto/translation-request-status-dto.ts"],"names":[],"mappings":""}

package/built/api/glossaries/enums/import-file-media-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum ImportFileMediaType {
+    CSV = "text/csv",
+    XML = "text/xml",
+    XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+}

package/built/api/glossaries/enums/import-file-media-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportFileMediaType = void 0;
+var ImportFileMediaType;
+(function (ImportFileMediaType) {
+    ImportFileMediaType["CSV"] = "text/csv";
+    ImportFileMediaType["XML"] = "text/xml";
+    ImportFileMediaType["XLSX"] = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+})(ImportFileMediaType = exports.ImportFileMediaType || (exports.ImportFileMediaType = {}));
+//# sourceMappingURL=import-file-media-type.js.map

package/built/api/glossaries/enums/import-file-media-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-file-media-type.js","sourceRoot":"","sources":["../../../../api/glossaries/enums/import-file-media-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC3B,uCAAgB,CAAA;IAChB,uCAAgB,CAAA;IAChB,iGAA0E,CAAA;AAC9E,CAAC,EAJW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAI9B"}

package/built/api/glossaries/enums/import-status.d.ts

@@ -0,0 +1,6 @@
+export declare enum ImportStatus {
+    PENDING = "PENDING",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCESSFUL = "SUCCESSFUL",
+    FAILED = "FAILED"
+}

package/built/api/glossaries/enums/import-status.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportStatus = void 0;
+var ImportStatus;
+(function (ImportStatus) {
+    ImportStatus["PENDING"] = "PENDING";
+    ImportStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    ImportStatus["SUCCESSFUL"] = "SUCCESSFUL";
+    ImportStatus["FAILED"] = "FAILED";
+})(ImportStatus = exports.ImportStatus || (exports.ImportStatus = {}));
+//# sourceMappingURL=import-status.js.map

package/built/api/glossaries/enums/import-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-status.js","sourceRoot":"","sources":["../../../../api/glossaries/enums/import-status.ts"],"names":[],"mappings":";;;AAAA,IAAY,YAKX;AALD,WAAY,YAAY;IACpB,mCAAmB,CAAA;IACnB,2CAA2B,CAAA;IAC3B,yCAAyB,CAAA;IACzB,iCAAiB,CAAA;AACrB,CAAC,EALW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAKvB"}

package/built/api/glossaries/enums/index.d.ts

@@ -6,3 +6,7 @@ export { DateFilterType } from "./date-filter-type";
 export { LabelType } from "./label-type";
 export { SortDirection } from "./sort-direction";
 export { SortField } from "./sort-field";
+export { PartOfSpeech } from "./part-of-speech";
+export { SuggestionStatus } from "./suggestion-status";
+export { ImportStatus } from "./import-status";
+export { ImportFileMediaType } from "./import-file-media-type";

package/built/api/glossaries/enums/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SortField = exports.SortDirection = exports.LabelType = exports.DateFilterType = exports.FilterLevel = exports.EntryState = exports.TbxVersion = exports.ExportFormat = void 0;
+exports.ImportFileMediaType = exports.ImportStatus = exports.SuggestionStatus = exports.PartOfSpeech = exports.SortField = exports.SortDirection = exports.LabelType = exports.DateFilterType = exports.FilterLevel = exports.EntryState = exports.TbxVersion = exports.ExportFormat = void 0;
 var export_format_1 = require("./export-format");
 Object.defineProperty(exports, "ExportFormat", { enumerable: true, get: function () { return export_format_1.ExportFormat; } });
 var tbx_version_1 = require("./tbx-version");
@@ -17,4 +17,12 @@ var sort_direction_1 = require("./sort-direction");
 Object.defineProperty(exports, "SortDirection", { enumerable: true, get: function () { return sort_direction_1.SortDirection; } });
 var sort_field_1 = require("./sort-field");
 Object.defineProperty(exports, "SortField", { enumerable: true, get: function () { return sort_field_1.SortField; } });
+var part_of_speech_1 = require("./part-of-speech");
+Object.defineProperty(exports, "PartOfSpeech", { enumerable: true, get: function () { return part_of_speech_1.PartOfSpeech; } });
+var suggestion_status_1 = require("./suggestion-status");
+Object.defineProperty(exports, "SuggestionStatus", { enumerable: true, get: function () { return suggestion_status_1.SuggestionStatus; } });
+var import_status_1 = require("./import-status");
+Object.defineProperty(exports, "ImportStatus", { enumerable: true, get: function () { return import_status_1.ImportStatus; } });
+var import_file_media_type_1 = require("./import-file-media-type");
+Object.defineProperty(exports, "ImportFileMediaType", { enumerable: true, get: function () { return import_file_media_type_1.ImportFileMediaType; } });
 //# sourceMappingURL=index.js.map

package/built/api/glossaries/enums/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../api/glossaries/enums/index.ts"],"names":[],"mappings":";;;AAAA,iDAA+C;AAAtC,6GAAA,YAAY,OAAA;AACrB,6CAA2C;AAAlC,yGAAA,UAAU,OAAA;AACnB,6CAA2C;AAAlC,yGAAA,UAAU,OAAA;AACnB,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AACpB,uDAAoD;AAA3C,kHAAA,cAAc,OAAA;AACvB,2CAAyC;AAAhC,uGAAA,SAAS,OAAA;AAClB,mDAAiD;AAAxC,+GAAA,aAAa,OAAA;AACtB,2CAAyC;AAAhC,uGAAA,SAAS,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../api/glossaries/enums/index.ts"],"names":[],"mappings":";;;AAAA,iDAA+C;AAAtC,6GAAA,YAAY,OAAA;AACrB,6CAA2C;AAAlC,yGAAA,UAAU,OAAA;AACnB,6CAA2C;AAAlC,yGAAA,UAAU,OAAA;AACnB,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AACpB,uDAAoD;AAA3C,kHAAA,cAAc,OAAA;AACvB,2CAAyC;AAAhC,uGAAA,SAAS,OAAA;AAClB,mDAAiD;AAAxC,+GAAA,aAAa,OAAA;AACtB,2CAAyC;AAAhC,uGAAA,SAAS,OAAA;AAClB,mDAAgD;AAAvC,8GAAA,YAAY,OAAA;AACrB,yDAAuD;AAA9C,qHAAA,gBAAgB,OAAA;AACzB,iDAA+C;AAAtC,6GAAA,YAAY,OAAA;AACrB,mEAA+D;AAAtD,6HAAA,mBAAmB,OAAA"}

package/built/api/glossaries/enums/part-of-speech.d.ts

@@ -0,0 +1,11 @@
+export declare enum PartOfSpeech {
+    NOUN = "NOUN",
+    VERB = "VERB",
+    ADJECTIVE = "ADJECTIVE",
+    ADVERB = "ADVERB",
+    PRONOUN = "PRONOUN",
+    PREPOSITION = "PREPOSITION",
+    INTERJECTION = "INTERJECTION",
+    CONJUNCTION = "CONJUNCTION",
+    PROPER_NOUN = "PROPER_NOUN"
+}

package/built/api/glossaries/enums/part-of-speech.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartOfSpeech = void 0;
+var PartOfSpeech;
+(function (PartOfSpeech) {
+    PartOfSpeech["NOUN"] = "NOUN";
+    PartOfSpeech["VERB"] = "VERB";
+    PartOfSpeech["ADJECTIVE"] = "ADJECTIVE";
+    PartOfSpeech["ADVERB"] = "ADVERB";
+    PartOfSpeech["PRONOUN"] = "PRONOUN";
+    PartOfSpeech["PREPOSITION"] = "PREPOSITION";
+    PartOfSpeech["INTERJECTION"] = "INTERJECTION";
+    PartOfSpeech["CONJUNCTION"] = "CONJUNCTION";
+    PartOfSpeech["PROPER_NOUN"] = "PROPER_NOUN";
+})(PartOfSpeech = exports.PartOfSpeech || (exports.PartOfSpeech = {}));
+//# sourceMappingURL=part-of-speech.js.map

package/built/api/glossaries/enums/part-of-speech.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"part-of-speech.js","sourceRoot":"","sources":["../../../../api/glossaries/enums/part-of-speech.ts"],"names":[],"mappings":";;;AAAA,IAAY,YAUX;AAVD,WAAY,YAAY;IACpB,6BAAa,CAAA;IACb,6BAAa,CAAA;IACb,uCAAuB,CAAA;IACvB,iCAAiB,CAAA;IACjB,mCAAmB,CAAA;IACnB,2CAA2B,CAAA;IAC3B,6CAA6B,CAAA;IAC7B,2CAA2B,CAAA;IAC3B,2CAA2B,CAAA;AAC/B,CAAC,EAVW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAUvB"}

package/built/api/glossaries/enums/suggestion-status.d.ts

@@ -0,0 +1,5 @@
+export declare enum SuggestionStatus {
+    STANDARD = "STANDARD",
+    SUGGESTED = "SUGGESTED",
+    APPROVED = "APPROVED"
+}

package/built/api/glossaries/enums/suggestion-status.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuggestionStatus = void 0;
+var SuggestionStatus;
+(function (SuggestionStatus) {
+    SuggestionStatus["STANDARD"] = "STANDARD";
+    SuggestionStatus["SUGGESTED"] = "SUGGESTED";
+    SuggestionStatus["APPROVED"] = "APPROVED";
+})(SuggestionStatus = exports.SuggestionStatus || (exports.SuggestionStatus = {}));
+//# sourceMappingURL=suggestion-status.js.map

package/built/api/glossaries/enums/suggestion-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggestion-status.js","sourceRoot":"","sources":["../../../../api/glossaries/enums/suggestion-status.ts"],"names":[],"mappings":";;;AAAA,IAAY,gBAIX;AAJD,WAAY,gBAAgB;IACxB,yCAAqB,CAAA;IACrB,2CAAuB,CAAA;IACvB,yCAAqB,CAAA;AACzB,CAAC,EAJW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAI3B"}

package/built/api/glossaries/index.d.ts

@@ -5,9 +5,48 @@ import { GlossaryDto } from "./dto/glossary-dto";
 import { SearchGlossariesParameters } from "./params/search-glossaries-parameters";
 import { SmartlingListResponse } from "../http/smartling-list-response";
 import { ExportEntriesParameters } from "./params/export-entries-parameters";
+import { CreateGlossaryParameters } from "./params/create-glossary-parameters";
+import { ArchiveGlossariesParameters } from "./params/archive-glossaries-parameters";
+import { SearchGlossaryCountsParameters } from "./params/search-glossary-counts-parameters";
+import { GlossaryUidsDto } from "./dto/glossary-uids-dto";
+import { GlossaryEntriesCountDto } from "./dto/glossary-entries-count-dto";
+import { CreateGlossaryEntryParameters } from "./params/create-glossary-entry-parameters";
+import { SearchGlossaryEntriesParameters } from "./params/search-glossary-entries-parameters";
+import { GlossaryEntryDto } from "./dto/glossary-entry-dto";
+import { EntriesBulkActionParameters } from "./params/entries-bulk-action-parameters";
+import { EntriesBulkLabelsParameters } from "./params/entries-bulk-labels-parameters";
+import { OperationDto } from "./dto/operation-dto";
+import { AuthorizeEntriesParameters } from "./params/authorize-entries-parameters";
+import { InitializeImportParameters } from "./params/initialize-import-parameters";
+import { GlossaryImportResultDto } from "./dto/glossary-import-result-dto";
+import { GlossaryImportStatusDto } from "./dto/glossary-import-status-dto";
+import { CreateLabelParameters } from "./params/create-label-parameters";
+import { LabelDto } from "./dto/label-dto";
 export declare class SmartlingGlossariesApi extends SmartlingBaseApi {
     constructor(smartlingApiBaseUrl: string, authApi: AccessTokenProvider, logger: Logger);
     searchGlossaries(accountUid: string, parameters: SearchGlossariesParameters): Promise<SmartlingListResponse<GlossaryDto>>;
     getGlossary(accountUid: string, glossaryUid: string): Promise<GlossaryDto>;
+    createGlossary(accountUid: string, parameters: CreateGlossaryParameters): Promise<GlossaryDto>;
+    updateGlossary(accountUid: string, glossaryUid: string, parameters: CreateGlossaryParameters): Promise<GlossaryDto>;
+    archiveGlossaries(accountUid: string, parameters: ArchiveGlossariesParameters): Promise<GlossaryUidsDto>;
+    restoreGlossaries(accountUid: string, parameters: ArchiveGlossariesParameters): Promise<GlossaryUidsDto>;
+    searchGlossariesWithEntriesCounts(accountUid: string, parameters: SearchGlossaryCountsParameters): Promise<SmartlingListResponse<GlossaryEntriesCountDto>>;
+    createGlossaryEntry(accountUid: string, glossaryUid: string, parameters: CreateGlossaryEntryParameters): Promise<GlossaryEntryDto>;
+    readGlossaryEntry(accountUid: string, glossaryUid: string, entryUid: string): Promise<GlossaryEntryDto>;
+    updateGlossaryEntry(accountUid: string, glossaryUid: string, entryUid: string, parameters: CreateGlossaryEntryParameters): Promise<GlossaryEntryDto>;
+    searchGlossaryEntries(accountUid: string, glossaryUid: string, parameters: SearchGlossaryEntriesParameters): Promise<SmartlingListResponse<GlossaryEntryDto>>;
+    archiveGlossaryEntries(accountUid: string, glossaryUid: string, parameters: EntriesBulkActionParameters): Promise<OperationDto>;
+    restoreGlossaryEntries(accountUid: string, glossaryUid: string, parameters: EntriesBulkActionParameters): Promise<OperationDto>;
+    removeGlossaryEntries(accountUid: string, glossaryUid: string, parameters: EntriesBulkActionParameters): Promise<OperationDto>;
+    addLabelsToGlossaryEntries(accountUid: string, glossaryUid: string, parameters: EntriesBulkLabelsParameters): Promise<OperationDto>;
+    removeLabelsFromGlossaryEntries(accountUid: string, glossaryUid: string, parameters: EntriesBulkLabelsParameters): Promise<OperationDto>;
+    authorizeEntriesForTranslation(accountUid: string, glossaryUid: string, parameters: AuthorizeEntriesParameters): Promise<OperationDto>;
+    initializeGlossaryImport(accountUid: string, glossaryUid: string, parameters: InitializeImportParameters): Promise<GlossaryImportResultDto>;
+    importStatus(accountUid: string, glossaryUid: string, importUid: string): Promise<GlossaryImportStatusDto>;
+    confirmGlossaryImport(accountUid: string, glossaryUid: string, importUid: string): Promise<GlossaryImportStatusDto>;
+    readAllGlossaryLabels(accountUid: string): Promise<SmartlingListResponse<LabelDto>>;
+    createGlossaryLabel(accountUid: string, parameters: CreateLabelParameters): Promise<LabelDto>;
+    updateGlossaryLabel(accountUid: string, labelUid: string, parameters: CreateLabelParameters): Promise<LabelDto>;
+    deleteGlossaryLabel(accountUid: string, labelUid: string): Promise<void>;
     exportGlossaryEntries(accountUid: string, glossaryUid: string, parameters: ExportEntriesParameters): Promise<string>;
 }

package/built/api/glossaries/index.js

@@ -8,8 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartlingGlossariesApi = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const form_data_utils_1 = require("../http/form-data-utils");
 const index_1 = require("../base/index");
 const response_body_type_1 = require("../base/enum/response-body-type");
 class SmartlingGlossariesApi extends index_1.SmartlingBaseApi {
@@ -28,6 +33,128 @@ class SmartlingGlossariesApi extends index_1.SmartlingBaseApi {
             return yield this.makeRequest("get", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}`);
         });
     }
+    createGlossary(accountUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries`, JSON.stringify(parameters.export()));
+        });
+    }
+    updateGlossary(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("put", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}`, JSON.stringify(parameters.export()));
+        });
+    }
+    archiveGlossaries(accountUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/archive`, JSON.stringify(parameters.export()));
+        });
+    }
+    restoreGlossaries(accountUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/unarchive`, JSON.stringify(parameters.export()));
+        });
+    }
+    searchGlossariesWithEntriesCounts(accountUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/search/count`, JSON.stringify(parameters.export()));
+        });
+    }
+    createGlossaryEntry(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries`, JSON.stringify(parameters.export()));
+        });
+    }
+    readGlossaryEntry(accountUid, glossaryUid, entryUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("get", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/${entryUid}`);
+        });
+    }
+    updateGlossaryEntry(accountUid, glossaryUid, entryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("put", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/${entryUid}`, JSON.stringify(parameters.export()));
+        });
+    }
+    searchGlossaryEntries(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/search`, JSON.stringify(parameters.export()));
+        });
+    }
+    archiveGlossaryEntries(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/archive`, JSON.stringify(parameters.export()));
+        });
+    }
+    restoreGlossaryEntries(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/unarchive`, JSON.stringify(parameters.export()));
+        });
+    }
+    removeGlossaryEntries(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/delete`, JSON.stringify(parameters.export()));
+        });
+    }
+    addLabelsToGlossaryEntries(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/add-labels`, JSON.stringify(parameters.export()));
+        });
+    }
+    removeLabelsFromGlossaryEntries(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/remove-labels`, JSON.stringify(parameters.export()));
+        });
+    }
+    authorizeEntriesForTranslation(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/authorization`, JSON.stringify(parameters.export()));
+        });
+    }
+    initializeGlossaryImport(accountUid, glossaryUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exported = parameters.export();
+            const formData = new form_data_1.default();
+            Object.keys(exported).forEach((key) => {
+                if (Array.isArray(exported[key])) {
+                    exported[key].forEach((value) => {
+                        formData.append(`${key}[]`, value);
+                    });
+                }
+                else {
+                    formData.append(key, exported[key]);
+                }
+            });
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/import`, formData, false, (0, form_data_utils_1.fixContentTypeHeaderCase)(formData));
+        });
+    }
+    importStatus(accountUid, glossaryUid, importUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("get", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/import/${importUid}`);
+        });
+    }
+    confirmGlossaryImport(accountUid, glossaryUid, importUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/import/${importUid}/confirm`);
+        });
+    }
+    readAllGlossaryLabels(accountUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("get", `${this.entrypoint}/accounts/${accountUid}/labels`);
+        });
+    }
+    createGlossaryLabel(accountUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/labels`, JSON.stringify(parameters.export()));
+        });
+    }
+    updateGlossaryLabel(accountUid, labelUid, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.makeRequest("put", `${this.entrypoint}/accounts/${accountUid}/labels/${labelUid}`, JSON.stringify(parameters.export()));
+        });
+    }
+    deleteGlossaryLabel(accountUid, labelUid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.makeRequest("delete", `${this.entrypoint}/accounts/${accountUid}/labels/${labelUid}`);
+        });
+    }
     exportGlossaryEntries(accountUid, glossaryUid, parameters) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.makeRequest("post", `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/download`, JSON.stringify(parameters.export()), response_body_type_1.ResponseBodyType.TEXT);