smartling-api-sdk-nodejs 3.2.2 → 3.3.0

package/.env.example

@@ -0,0 +1,13 @@
+# Credentials for test/integration/glossaries.spec.ts.
+# Copy this file to .env and fill in real values to run: npm run test:integration
+# Without a real .env, the integration suite skips (shows as pending) rather than failing.
+
+# Optional: override the Smartling API base URL (defaults to https://api.smartling.com)
+# SMARTLING_API_BASE_URL=https://api.smartling.com
+
+SMARTLING_ACCOUNT_UID=
+SMARTLING_USER_ID=
+SMARTLING_USER_SECRET=
+
+# Optional: set to "true" to print every integration test's raw API response to the console.
+SMARTLING_LOG_RESPONSES=false

package/api/base/base-api.ts

@@ -166,7 +166,8 @@ export class SmartlingBaseApi {
                     "lastModified",
                     "attemptDate",
                     "translationJobWorkflowStepDueDate",
-                    "translationJobOverallDueDate"
+                    "translationJobOverallDueDate",
+                    "requestDateTime"
                 ];
 
                 if (dateProperties.includes(key) && value) {

package/api/base/base-file-api.ts

@@ -9,9 +9,14 @@ export class SmartlingBaseFileApi extends SmartlingBaseApi {
         const contentDisposition = response.headers.get("content-disposition");
         let fileName;
         if (contentDisposition) {
-            const fileNameMatch = contentDisposition.match(/filename="((?:[^"\\]|\\.)*)"/);
-            if (fileNameMatch) {
-                fileName = fileNameMatch[1].replace(/\\"/g, "\"");
+            const encodedFileNameMatch = contentDisposition.match(/filename\*=[^']*''([^;]+)/);
+            if (encodedFileNameMatch) {
+                fileName = decodeURIComponent(encodedFileNameMatch[1]);
+            } else {
+                const fileNameMatch = contentDisposition.match(/filename="((?:[^"\\]|\\.)*)"/);
+                if (fileNameMatch) {
+                    fileName = fileNameMatch[1].replace(/\\"/g, "\"");
+                }
             }
         }
         return {

package/api/glossaries/dto/custom-field-value-dto.ts

@@ -0,0 +1,6 @@
+export interface CustomFieldValueDto {
+    fieldUid: string;
+    fieldValue: string;
+    fieldName?: string;
+    localeId?: string;
+}

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

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

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

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

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

@@ -0,0 +1,23 @@
+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/api/glossaries/dto/glossary-import-result-dto.ts

@@ -0,0 +1,11 @@
+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/api/glossaries/dto/glossary-import-status-dto.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+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/api/glossaries/dto/translation-request-status-dto.ts

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

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

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

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

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

package/api/glossaries/enums/index.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/api/glossaries/enums/part-of-speech.ts

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

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

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

package/api/glossaries/index.ts

@@ -1,3 +1,5 @@
+import FormData from "form-data";
+import { fixContentTypeHeaderCase } from "../http/form-data-utils";
 import { SmartlingBaseApi } from "../base/index";
 import { AccessTokenProvider } from "../auth/access-token-provider";
 import { Logger } from "../logger";
@@ -6,6 +8,23 @@ import { SearchGlossariesParameters } from "./params/search-glossaries-parameter
 import { SmartlingListResponse } from "../http/smartling-list-response";
 import { ExportEntriesParameters } from "./params/export-entries-parameters";
 import { ResponseBodyType } from "../base/enum/response-body-type";
+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 class SmartlingGlossariesApi extends SmartlingBaseApi {
     constructor(smartlingApiBaseUrl: string, authApi: AccessTokenProvider, logger: Logger) {
@@ -32,6 +51,268 @@ export class SmartlingGlossariesApi extends SmartlingBaseApi {
         );
     }
 
+    async createGlossary(
+        accountUid: string,
+        parameters: CreateGlossaryParameters
+    ): Promise<GlossaryDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async updateGlossary(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: CreateGlossaryParameters
+    ): Promise<GlossaryDto> {
+        return await this.makeRequest(
+            "put",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async archiveGlossaries(
+        accountUid: string,
+        parameters: ArchiveGlossariesParameters
+    ): Promise<GlossaryUidsDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/archive`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async restoreGlossaries(
+        accountUid: string,
+        parameters: ArchiveGlossariesParameters
+    ): Promise<GlossaryUidsDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/unarchive`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async searchGlossariesWithEntriesCounts(
+        accountUid: string,
+        parameters: SearchGlossaryCountsParameters
+    ): Promise<SmartlingListResponse<GlossaryEntriesCountDto>> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/search/count`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async createGlossaryEntry(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: CreateGlossaryEntryParameters
+    ): Promise<GlossaryEntryDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async readGlossaryEntry(
+        accountUid: string,
+        glossaryUid: string,
+        entryUid: string
+    ): Promise<GlossaryEntryDto> {
+        return await this.makeRequest(
+            "get",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/${entryUid}`
+        );
+    }
+
+    async updateGlossaryEntry(
+        accountUid: string,
+        glossaryUid: string,
+        entryUid: string,
+        parameters: CreateGlossaryEntryParameters
+    ): Promise<GlossaryEntryDto> {
+        return await this.makeRequest(
+            "put",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/${entryUid}`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async searchGlossaryEntries(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: SearchGlossaryEntriesParameters
+    ): Promise<SmartlingListResponse<GlossaryEntryDto>> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/search`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async archiveGlossaryEntries(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: EntriesBulkActionParameters
+    ): Promise<OperationDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/archive`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async restoreGlossaryEntries(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: EntriesBulkActionParameters
+    ): Promise<OperationDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/unarchive`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async removeGlossaryEntries(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: EntriesBulkActionParameters
+    ): Promise<OperationDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/delete`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async addLabelsToGlossaryEntries(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: EntriesBulkLabelsParameters
+    ): Promise<OperationDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/add-labels`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async removeLabelsFromGlossaryEntries(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: EntriesBulkLabelsParameters
+    ): Promise<OperationDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/remove-labels`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async authorizeEntriesForTranslation(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: AuthorizeEntriesParameters
+    ): Promise<OperationDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/entries/authorization`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async initializeGlossaryImport(
+        accountUid: string,
+        glossaryUid: string,
+        parameters: InitializeImportParameters
+    ): Promise<GlossaryImportResultDto> {
+        const exported = parameters.export();
+        const formData = new FormData();
+
+        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 await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/import`,
+            formData,
+            false,
+            fixContentTypeHeaderCase(formData)
+        );
+    }
+
+    async importStatus(
+        accountUid: string,
+        glossaryUid: string,
+        importUid: string
+    ): Promise<GlossaryImportStatusDto> {
+        return await this.makeRequest(
+            "get",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/import/${importUid}`
+        );
+    }
+
+    async confirmGlossaryImport(
+        accountUid: string,
+        glossaryUid: string,
+        importUid: string
+    ): Promise<GlossaryImportStatusDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/glossaries/${glossaryUid}/import/${importUid}/confirm`
+        );
+    }
+
+    async readAllGlossaryLabels(accountUid: string): Promise<SmartlingListResponse<LabelDto>> {
+        return await this.makeRequest(
+            "get",
+            `${this.entrypoint}/accounts/${accountUid}/labels`
+        );
+    }
+
+    async createGlossaryLabel(
+        accountUid: string,
+        parameters: CreateLabelParameters
+    ): Promise<LabelDto> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/labels`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async updateGlossaryLabel(
+        accountUid: string,
+        labelUid: string,
+        parameters: CreateLabelParameters
+    ): Promise<LabelDto> {
+        return await this.makeRequest(
+            "put",
+            `${this.entrypoint}/accounts/${accountUid}/labels/${labelUid}`,
+            JSON.stringify(parameters.export())
+        );
+    }
+
+    async deleteGlossaryLabel(accountUid: string, labelUid: string): Promise<void> {
+        await this.makeRequest(
+            "delete",
+            `${this.entrypoint}/accounts/${accountUid}/labels/${labelUid}`
+        );
+    }
+
     async exportGlossaryEntries(
         accountUid: string,
         glossaryUid: string,

package/api/glossaries/params/archive-glossaries-parameters.ts

@@ -0,0 +1,9 @@
+import { BaseParameters } from "../../parameters/index";
+
+export class ArchiveGlossariesParameters extends BaseParameters {
+    setGlossaryUids(glossaryUids: Array<string>): ArchiveGlossariesParameters {
+        this.set("glossaryUids", glossaryUids);
+
+        return this;
+    }
+}

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

@@ -0,0 +1,37 @@
+import { BaseParameters } from "../../parameters/index";
+import { ExportEntriesFilterDto } from "../dto/export-entries-filter-dto";
+import { GlossaryLocaleWorkflowDto } from "../dto/locale-workflow-dto";
+
+export class AuthorizeEntriesParameters extends BaseParameters {
+    setSourceLocale(sourceLocale: string): AuthorizeEntriesParameters {
+        this.set("sourceLocale", sourceLocale);
+
+        return this;
+    }
+
+    setProjectId(projectId: string): AuthorizeEntriesParameters {
+        this.set("projectId", projectId);
+
+        return this;
+    }
+
+    setFilter(filter: ExportEntriesFilterDto): AuthorizeEntriesParameters {
+        this.set("filter", filter);
+
+        return this;
+    }
+
+    setLocaleWorkflows(
+        localeWorkflows: Array<GlossaryLocaleWorkflowDto>
+    ): AuthorizeEntriesParameters {
+        this.set("localeWorkflows", localeWorkflows);
+
+        return this;
+    }
+
+    setMissingTranslationsOnly(missingTranslationsOnly: boolean): AuthorizeEntriesParameters {
+        this.set("missingTranslationsOnly", missingTranslationsOnly);
+
+        return this;
+    }
+}

package/api/glossaries/params/create-glossary-entry-parameters.ts

@@ -0,0 +1,50 @@
+import { BaseParameters } from "../../parameters/index";
+import { PartOfSpeech } from "../enums/part-of-speech";
+import { GlossaryTranslationDto } from "../dto/translation-dto";
+import { CustomFieldValueDto } from "../dto/custom-field-value-dto";
+
+export class CreateGlossaryEntryParameters extends BaseParameters {
+    setDefinition(definition: string): CreateGlossaryEntryParameters {
+        this.set("definition", definition);
+
+        return this;
+    }
+
+    setPartOfSpeech(partOfSpeech: PartOfSpeech): CreateGlossaryEntryParameters {
+        this.set("partOfSpeech", partOfSpeech);
+
+        return this;
+    }
+
+    setLabelUids(labelUids: Array<string>): CreateGlossaryEntryParameters {
+        this.set("labelUids", labelUids);
+
+        return this;
+    }
+
+    setSkipMissingTranslations(skipMissingTranslations: boolean): CreateGlossaryEntryParameters {
+        this.set("skipMissingTranslations", skipMissingTranslations);
+
+        return this;
+    }
+
+    setTranslations(translations: Array<GlossaryTranslationDto>): CreateGlossaryEntryParameters {
+        this.set("translations", translations);
+
+        return this;
+    }
+
+    setCustomFieldValues(
+        customFieldValues: Array<CustomFieldValueDto>
+    ): CreateGlossaryEntryParameters {
+        this.set("customFieldValues", customFieldValues);
+
+        return this;
+    }
+
+    setSuggestion(suggestion: boolean): CreateGlossaryEntryParameters {
+        this.set("suggestion", suggestion);
+
+        return this;
+    }
+}

package/api/glossaries/params/create-glossary-parameters.ts

@@ -0,0 +1,40 @@
+import { BaseParameters } from "../../parameters/index";
+import { FallbackLocaleDto } from "../dto/fallback-locale-dto";
+
+export class CreateGlossaryParameters extends BaseParameters {
+    setGlossaryName(glossaryName: string): CreateGlossaryParameters {
+        this.set("glossaryName", glossaryName);
+
+        return this;
+    }
+
+    setDescription(description: string): CreateGlossaryParameters {
+        this.set("description", description);
+
+        return this;
+    }
+
+    setVerificationMode(verificationMode: boolean): CreateGlossaryParameters {
+        this.set("verificationMode", verificationMode);
+
+        return this;
+    }
+
+    setLocaleIds(localeIds: Array<string>): CreateGlossaryParameters {
+        this.set("localeIds", localeIds);
+
+        return this;
+    }
+
+    setFallbackLocales(fallbackLocales: Array<FallbackLocaleDto>): CreateGlossaryParameters {
+        this.set("fallbackLocales", fallbackLocales);
+
+        return this;
+    }
+
+    setMtOptimized(mtOptimized: boolean): CreateGlossaryParameters {
+        this.set("mtOptimized", mtOptimized);
+
+        return this;
+    }
+}