smartling-api-sdk-nodejs 2.24.3 → 2.24.5

package/.scannerwork/report-task.txt

@@ -2,5 +2,5 @@ projectKey=smartling-api-sdk-nodejs
 serverUrl=https://sonar-next.connectors.stg.smartling.net
 serverVersion=8.6.1.40680
 dashboardUrl=https://sonar-next.connectors.stg.smartling.net/dashboard?id=smartling-api-sdk-nodejs
-ceTaskId=AZitJlMtBVSmsPhymERt
-ceTaskUrl=https://sonar-next.connectors.stg.smartling.net/api/ce/task?id=AZitJlMtBVSmsPhymERt
+ceTaskId=AZk98cLrJYLo-yRQ8Fjl
+ceTaskUrl=https://sonar-next.connectors.stg.smartling.net/api/ce/task?id=AZk98cLrJYLo-yRQ8Fjl

package/api/glossaries/dto/date-filter-dto.ts

@@ -0,0 +1,10 @@
+import { FilterLevel } from "../enums/filter-level";
+import { DateFilterType } from "../enums/date-filter-type";
+
+export interface DateFilterDto {
+    level: FilterLevel;
+    type: DateFilterType;
+    date?: string;
+    from?: string;
+    to?: string;
+}

package/api/glossaries/dto/entry-sorting-dto.ts

@@ -0,0 +1,8 @@
+import { SortField } from "../enums/sort-field";
+import { SortDirection } from "../enums/sort-direction";
+
+export interface EntrySortingDto {
+    field: SortField;
+    direction: SortDirection;
+    localeId?: string;
+}

package/api/glossaries/dto/export-entries-filter-dto.ts

@@ -0,0 +1,25 @@
+import { EntryState } from "../enums/entry-state";
+import { LabelTypeDto } from "./label-type-dto";
+import { DateFilterDto } from "./date-filter-dto";
+import { UserFilterDto } from "./user-filter-dto";
+import { PaginationDto } from "./pagination-dto";
+import { EntrySortingDto } from "./entry-sorting-dto";
+
+export interface ExportEntriesFilterDto {
+    query?: string;
+    localeIds?: Array<string>;
+    entryUids?: Array<string>;
+    entryState?: EntryState;
+    missingTranslationLocaleId?: string;
+    presentTranslationLocaleId?: string;
+    dntLocaleId?: string;
+    returnFallbackTranslations?: boolean;
+    labels?: LabelTypeDto;
+    dntTermSet?: boolean;
+    created?: DateFilterDto;
+    lastModified?: DateFilterDto;
+    createdBy?: UserFilterDto;
+    lastModifiedBy?: UserFilterDto;
+    paging?: PaginationDto;
+    sorting?: EntrySortingDto;
+}

package/api/glossaries/dto/label-type-dto.ts

@@ -0,0 +1,6 @@
+import { LabelType } from "../enums/label-type";
+
+export interface LabelTypeDto {
+    type: LabelType;
+    labelUids?: Array<string>;
+}

package/api/glossaries/dto/user-filter-dto.ts

@@ -0,0 +1,6 @@
+import { FilterLevel } from "../enums/filter-level";
+
+export interface UserFilterDto {
+    level: FilterLevel;
+    userIds: Array<string>;
+}

package/api/glossaries/enums/date-filter-type.ts

@@ -0,0 +1,6 @@
+export enum DateFilterType {
+    AFTER = "after",
+    BEFORE = "before",
+    DATE_RANGE = "date_range",
+    EXACT = "exact"
+}

package/api/glossaries/enums/entry-state.ts

@@ -0,0 +1,5 @@
+export enum EntryState {
+    ACTIVE = "ACTIVE",
+    ARCHIVED = "ARCHIVED",
+    BOTH = "BOTH"
+}

package/api/glossaries/enums/export-format.ts

@@ -0,0 +1,5 @@
+export enum ExportFormat {
+    CSV = "CSV",
+    XLSX = "XLSX",
+    TBX = "TBX"
+}

package/api/glossaries/enums/filter-level.ts

@@ -0,0 +1,5 @@
+export enum FilterLevel {
+    ENTRY = "ENTRY",
+    LOCALE = "LOCALE",
+    ANY = "ANY"
+}

package/api/glossaries/enums/index.ts

@@ -0,0 +1,8 @@
+export { ExportFormat } from "./export-format";
+export { TbxVersion } from "./tbx-version";
+export { EntryState } from "./entry-state";
+export { FilterLevel } from "./filter-level";
+export { DateFilterType } from "./date-filter-type";
+export { LabelType } from "./label-type";
+export { SortDirection } from "./sort-direction";
+export { SortField } from "./sort-field";

package/api/glossaries/enums/label-type.ts

@@ -0,0 +1,5 @@
+export enum LabelType {
+    EMPTY = "empty",
+    ANY = "any",
+    ASSOCIATED = "associated"
+}

package/api/glossaries/enums/sort-direction.ts

@@ -0,0 +1,4 @@
+export enum SortDirection {
+    ASC = "ASC",
+    DESC = "DESC"
+}

package/api/glossaries/enums/sort-field.ts

@@ -0,0 +1,5 @@
+export enum SortField {
+    TERM = "term",
+    CREATED_DATE = "createdDate",
+    LAST_MODIFIED_DATE = "lastModifiedDate"
+}

package/api/glossaries/enums/tbx-version.ts

@@ -0,0 +1,4 @@
+export enum TbxVersion {
+    TBXcoreStructV02 = "TBXcoreStructV02",
+    TBXcoreStructV03 = "TBXcoreStructV03"
+}

package/api/glossaries/index.ts

@@ -4,6 +4,7 @@ import { Logger } from "../logger";
 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";
 
 export class SmartlingGlossariesApi extends SmartlingBaseApi {
     constructor(smartlingApiBaseUrl: string, authApi: AccessTokenProvider, logger: Logger) {
@@ -29,4 +30,16 @@ export class SmartlingGlossariesApi extends SmartlingBaseApi {
             `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}`
         );
     }
+
+    async exportGlossaryEntries(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: ExportEntriesParameters
+    ): Promise<void> {
+        await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/download`,
+            JSON.stringify(parameters.export())
+        );
+    }
 }

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

@@ -0,0 +1,160 @@
+import { BaseParameters } from "../../parameters";
+import { ExportEntriesFilterDto } from "../dto/export-entries-filter-dto";
+import { ExportFormat } from "../enums/export-format";
+import { TbxVersion } from "../enums/tbx-version";
+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 ExportEntriesParameters extends BaseParameters {
+    constructor() {
+        super();
+        this.set("filter", {});
+        this.set("localeIds", []);
+    }
+
+    setFormat(format: ExportFormat): ExportEntriesParameters {
+        this.set("format", format);
+        return this;
+    }
+
+    setTbxVersion(tbxVersion: TbxVersion): ExportEntriesParameters {
+        this.set("tbxVersion", tbxVersion);
+        return this;
+    }
+
+    setFocusLocaleId(focusLocaleId: string): ExportEntriesParameters {
+        this.set("focusLocaleId", focusLocaleId);
+        return this;
+    }
+
+    setLocaleIds(localeIds: Array<string>): ExportEntriesParameters {
+        this.set("localeIds", localeIds);
+        return this;
+    }
+
+    setSkipEntries(skipEntries: boolean): ExportEntriesParameters {
+        this.set("skipEntries", skipEntries);
+        return this;
+    }
+
+    setFilter(filter: ExportEntriesFilterDto): ExportEntriesParameters {
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterQuery(query: string): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.query = query;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterLocaleIds(localeIds: Array<string>): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.localeIds = localeIds;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterEntryUids(entryUids: Array<string>): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.entryUids = entryUids;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterEntryState(entryState: EntryState): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.entryState = entryState;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterMissingTranslationLocaleId(localeId: string): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.missingTranslationLocaleId = localeId;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterPresentTranslationLocaleId(localeId: string): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.presentTranslationLocaleId = localeId;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterDntLocaleId(localeId: string): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.dntLocaleId = localeId;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterReturnFallbackTranslations(returnFallback: boolean): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.returnFallbackTranslations = returnFallback;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterLabels(labels: LabelTypeDto): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.labels = labels;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterDntTermSet(dntTermSet: boolean): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.dntTermSet = dntTermSet;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterCreated(created: DateFilterDto): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.created = created;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterLastModified(lastModified: DateFilterDto): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.lastModified = lastModified;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterCreatedBy(createdBy: UserFilterDto): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.createdBy = createdBy;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterLastModifiedBy(lastModifiedBy: UserFilterDto): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.lastModifiedBy = lastModifiedBy;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterPaging(paging: PaginationDto): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.paging = paging;
+        this.set("filter", filter);
+        return this;
+    }
+
+    setFilterSorting(sorting: EntrySortingDto): ExportEntriesParameters {
+        const filter = this.parameters.filter || {};
+        filter.sorting = sorting;
+        this.set("filter", filter);
+        return this;
+    }
+}

package/api/strings/dto/create-strings-response-dto.ts

@@ -0,0 +1,10 @@
+import { CreatedStringItemDto } from "./created-string-item-dto";
+
+interface CreateStringsResponseDto {
+    wordCount: number;
+    stringCount: number;
+    processUid?: string;
+    items: CreatedStringItemDto[];
+}
+
+export { CreateStringsResponseDto };

package/api/strings/dto/created-string-item-dto.ts

@@ -0,0 +1,9 @@
+interface CreatedStringItemDto {
+    variant: string;
+    stringText: string;
+    parsedStringText: string;
+    hashcode: string;
+    overWritten: boolean;
+}
+
+export { CreatedStringItemDto };

package/api/strings/dto/process-state-enum.ts

@@ -0,0 +1,7 @@
+enum ProcessState {
+    OPEN = "OPEN",
+    CLOSED = "CLOSED",
+    FAILED = "FAILED"
+}
+
+export { ProcessState };

package/api/strings/dto/process-statistics-dto.ts

@@ -0,0 +1,8 @@
+interface ProcessStatisticsDto {
+    requested: number;
+    processed: number;
+    errored: number;
+    skipped: number;
+}
+
+export { ProcessStatisticsDto };

package/api/strings/dto/process-status-dto.ts

@@ -0,0 +1,12 @@
+import { ProcessStatisticsDto } from "./process-statistics-dto";
+import { ProcessState } from "./process-state-enum";
+
+interface ProcessStatusDto {
+    processUid: string;
+    processState: ProcessState;
+    createdDate: string;
+    modifiedDate: string;
+    processStatistics: ProcessStatisticsDto;
+}
+
+export { ProcessStatusDto, ProcessState };

package/api/strings/index.ts

@@ -1,8 +1,11 @@
 import { SmartlingBaseApi } from "../base/index";
 import { AccessTokenProvider } from "../auth/access-token-provider";
 import { FetchSourceStringsParameters } from "./params/fetch-source-strings-parameters";
+import { CreateStringsParameters } from "./params/create-strings-parameters";
 import { SmartlingListResponse } from "../http/smartling-list-response";
 import { SourceStringDto } from "./dto/source-string-dto";
+import { CreateStringsResponseDto } from "./dto/create-strings-response-dto";
+import { ProcessStatusDto } from "./dto/process-status-dto";
 import { Logger } from "../logger";
 
 export class SmartlingStringsApi extends SmartlingBaseApi {
@@ -21,4 +24,25 @@ export class SmartlingStringsApi extends SmartlingBaseApi {
             params.export()
         );
     }
+
+    async createStrings(
+        projectUid: string,
+        params: CreateStringsParameters
+    ): Promise<CreateStringsResponseDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/${projectUid}`,
+            JSON.stringify(params.export())
+        );
+    }
+
+    async getCreateStringStatus(
+        projectUid: string,
+        processUid: string
+    ): Promise<SmartlingListResponse<ProcessStatusDto>> {
+        return await this.makeRequest(
+            "get",
+            `${this.entrypoint}/${projectUid}/processes/${processUid}`
+        );
+    }
 }

package/api/strings/params/create-strings-parameters.ts

@@ -0,0 +1,36 @@
+import { BaseParameters } from "../../parameters/index";
+import { StringItemParameters } from "./string-item-parameters";
+
+export class CreateStringsParameters extends BaseParameters {
+    public setNamespace(namespace: string): CreateStringsParameters {
+        this.set("namespace", namespace);
+        return this;
+    }
+
+    public setPlaceholderFormat(placeholderFormat: string): CreateStringsParameters {
+        this.set("placeholderFormat", placeholderFormat);
+        return this;
+    }
+
+    public setPlaceholderFormatCustom(placeholderFormatCustom: string): CreateStringsParameters {
+        this.set("placeholderFormatCustom", placeholderFormatCustom);
+        return this;
+    }
+
+    public setStrings(strings: StringItemParameters[]): CreateStringsParameters {
+        if (strings.length > 100) {
+            throw new Error("Maximum 100 strings can be posted in any given request");
+        }
+        this.set("strings", strings);
+        return this;
+    }
+
+    public addString(stringItem: StringItemParameters): CreateStringsParameters {
+        const currentStrings: StringItemParameters[] = this.parameters.strings || [];
+        if (currentStrings.length >= 100) {
+            throw new Error("Maximum 100 strings can be posted in any given request");
+        }
+        this.set("strings", [...currentStrings, stringItem]);
+        return this;
+    }
+}

package/api/strings/params/string-item-parameters.ts

@@ -0,0 +1,43 @@
+export class StringItemParameters {
+    private stringText: string;
+    private variant?: string;
+    private callbackUrl?: string;
+    private callbackMethod?: string;
+    private instruction?: string;
+    private format?: string;
+    private maxLength?: number;
+
+    constructor(stringText: string) {
+        this.stringText = stringText;
+    }
+
+    public setVariant(variant: string): StringItemParameters {
+        this.variant = variant;
+        return this;
+    }
+
+    public setCallbackUrl(callbackUrl: string): StringItemParameters {
+        this.callbackUrl = callbackUrl;
+        return this;
+    }
+
+    public setCallbackMethod(callbackMethod: string): StringItemParameters {
+        this.callbackMethod = callbackMethod;
+        return this;
+    }
+
+    public setInstruction(instruction: string): StringItemParameters {
+        this.instruction = instruction;
+        return this;
+    }
+
+    public setFormat(format: string): StringItemParameters {
+        this.format = format;
+        return this;
+    }
+
+    public setMaxLength(maxLength: number): StringItemParameters {
+        this.maxLength = maxLength;
+        return this;
+    }
+}

package/built/api/glossaries/dto/date-filter-dto.d.ts

@@ -0,0 +1,9 @@
+import { FilterLevel } from "../enums/filter-level";
+import { DateFilterType } from "../enums/date-filter-type";
+export interface DateFilterDto {
+    level: FilterLevel;
+    type: DateFilterType;
+    date?: string;
+    from?: string;
+    to?: string;
+}

package/built/api/glossaries/dto/date-filter-dto.js

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

package/built/api/glossaries/dto/date-filter-dto.js.map

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

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

@@ -0,0 +1,7 @@
+import { SortField } from "../enums/sort-field";
+import { SortDirection } from "../enums/sort-direction";
+export interface EntrySortingDto {
+    field: SortField;
+    direction: SortDirection;
+    localeId?: string;
+}

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

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

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

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

package/built/api/glossaries/dto/export-entries-filter-dto.d.ts

@@ -0,0 +1,24 @@
+import { EntryState } from "../enums/entry-state";
+import { LabelTypeDto } from "./label-type-dto";
+import { DateFilterDto } from "./date-filter-dto";
+import { UserFilterDto } from "./user-filter-dto";
+import { PaginationDto } from "./pagination-dto";
+import { EntrySortingDto } from "./entry-sorting-dto";
+export interface ExportEntriesFilterDto {
+    query?: string;
+    localeIds?: Array<string>;
+    entryUids?: Array<string>;
+    entryState?: EntryState;
+    missingTranslationLocaleId?: string;
+    presentTranslationLocaleId?: string;
+    dntLocaleId?: string;
+    returnFallbackTranslations?: boolean;
+    labels?: LabelTypeDto;
+    dntTermSet?: boolean;
+    created?: DateFilterDto;
+    lastModified?: DateFilterDto;
+    createdBy?: UserFilterDto;
+    lastModifiedBy?: UserFilterDto;
+    paging?: PaginationDto;
+    sorting?: EntrySortingDto;
+}

package/built/api/glossaries/dto/export-entries-filter-dto.js

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

package/built/api/glossaries/dto/export-entries-filter-dto.js.map

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

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

@@ -0,0 +1,5 @@
+import { LabelType } from "../enums/label-type";
+export interface LabelTypeDto {
+    type: LabelType;
+    labelUids?: Array<string>;
+}

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

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

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

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

package/built/api/glossaries/dto/user-filter-dto.d.ts

@@ -0,0 +1,5 @@
+import { FilterLevel } from "../enums/filter-level";
+export interface UserFilterDto {
+    level: FilterLevel;
+    userIds: Array<string>;
+}

package/built/api/glossaries/dto/user-filter-dto.js

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

package/built/api/glossaries/dto/user-filter-dto.js.map

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

package/built/api/glossaries/enums/date-filter-type.d.ts

@@ -0,0 +1,6 @@
+export declare enum DateFilterType {
+    AFTER = "after",
+    BEFORE = "before",
+    DATE_RANGE = "date_range",
+    EXACT = "exact"
+}

package/built/api/glossaries/enums/date-filter-type.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateFilterType = void 0;
+var DateFilterType;
+(function (DateFilterType) {
+    DateFilterType["AFTER"] = "after";
+    DateFilterType["BEFORE"] = "before";
+    DateFilterType["DATE_RANGE"] = "date_range";
+    DateFilterType["EXACT"] = "exact";
+})(DateFilterType = exports.DateFilterType || (exports.DateFilterType = {}));
+//# sourceMappingURL=date-filter-type.js.map

package/built/api/glossaries/enums/date-filter-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-filter-type.js","sourceRoot":"","sources":["../../../../api/glossaries/enums/date-filter-type.ts"],"names":[],"mappings":";;;AAAA,IAAY,cAKX;AALD,WAAY,cAAc;IACtB,iCAAe,CAAA;IACf,mCAAiB,CAAA;IACjB,2CAAyB,CAAA;IACzB,iCAAe,CAAA;AACnB,CAAC,EALW,cAAc,GAAd,sBAAc,KAAd,sBAAc,QAKzB"}

package/built/api/glossaries/enums/entry-state.d.ts

@@ -0,0 +1,5 @@
+export declare enum EntryState {
+    ACTIVE = "ACTIVE",
+    ARCHIVED = "ARCHIVED",
+    BOTH = "BOTH"
+}

package/built/api/glossaries/enums/entry-state.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryState = void 0;
+var EntryState;
+(function (EntryState) {
+    EntryState["ACTIVE"] = "ACTIVE";
+    EntryState["ARCHIVED"] = "ARCHIVED";
+    EntryState["BOTH"] = "BOTH";
+})(EntryState = exports.EntryState || (exports.EntryState = {}));
+//# sourceMappingURL=entry-state.js.map

package/built/api/glossaries/enums/entry-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-state.js","sourceRoot":"","sources":["../../../../api/glossaries/enums/entry-state.ts"],"names":[],"mappings":";;;AAAA,IAAY,UAIX;AAJD,WAAY,UAAU;IAClB,+BAAiB,CAAA;IACjB,mCAAqB,CAAA;IACrB,2BAAa,CAAA;AACjB,CAAC,EAJW,UAAU,GAAV,kBAAU,KAAV,kBAAU,QAIrB"}

package/built/api/glossaries/enums/export-format.d.ts

@@ -0,0 +1,5 @@
+export declare enum ExportFormat {
+    CSV = "CSV",
+    XLSX = "XLSX",
+    TBX = "TBX"
+}