import { CrowdinApi, DownloadLink, PaginationOptions, PatchRequest, ResponseList, ResponseObject, Status } from '../core';
/**
 * Glossaries help to explain some specific terms or the ones often used in the project so that they can be properly and consistently translated.
 *
 * Use API to manage glossaries or specific terms.
 * Glossary export and import are asynchronous operations and shall be completed with sequence of API methods.
 */
export declare class Glossaries extends CrowdinApi {
    /**
     * @param options optional parameters for the request
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.getMany
     */
    listGlossaries(options?: GlossariesModel.ListGlossariesOptions): Promise<ResponseList<GlossariesModel.Glossary>>;
    /**
     * @param groupId group identifier
     * @param limit maximum number of items to retrieve (default 25)
     * @param offset starting offset in the collection (default 0)
     * @deprecated optional parameters should be passed through an object
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.getMany
     */
    listGlossaries(groupId?: number, limit?: number, offset?: number): Promise<ResponseList<GlossariesModel.Glossary>>;
    /**
     * @param request request body
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.post
     */
    addGlossary(request: GlossariesModel.CreateGlossaryRequest): Promise<ResponseObject<GlossariesModel.Glossary>>;
    /**
     * @param glossaryId glossary identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.get
     */
    getGlossary(glossaryId: number): Promise<ResponseObject<GlossariesModel.Glossary>>;
    /**
     * @param glossaryId glossary identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.delete
     */
    deleteGlossary(glossaryId: number): Promise<void>;
    /**
     * @param glossaryId glossary identifier
     * @param request request body
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.patch
     */
    editGlossary(glossaryId: number, request: PatchRequest[]): Promise<ResponseObject<GlossariesModel.Glossary>>;
    /**
     * @param glossaryId glossary identifier
     * @param request request body
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.exports.post
     */
    exportGlossary(glossaryId: number, request: GlossariesModel.ExportGlossaryRequest): Promise<ResponseObject<Status<GlossariesModel.GlossaryExportStatusAttribute>>>;
    /**
     * @param glossaryId glossary identifier
     * @param exportId export identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.exports.get
     */
    checkGlossaryExportStatus(glossaryId: number, exportId: string): Promise<ResponseObject<Status<GlossariesModel.GlossaryExportStatusAttribute>>>;
    /**
     * @param glossaryId glossary identifier
     * @param exportId export identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.exports.download.download
     */
    downloadGlossary(glossaryId: number, exportId: string): Promise<ResponseObject<DownloadLink>>;
    /**
     * @param glossaryId glossary identifier
     * @param request request body
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.imports.post
     */
    importGlossaryFile(glossaryId: number, request: GlossariesModel.GlossaryFile): Promise<ResponseObject<Status<GlossariesModel.GlossaryImportStatusAttribute>>>;
    /**
     * @param glossaryId glossary identifier
     * @param importId import identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.imports.get
     */
    checkGlossaryImportStatus(glossaryId: number, importId: string): Promise<ResponseObject<Status<GlossariesModel.GlossaryImportStatusAttribute>>>;
    /**
     * @param glossaryId glossary identifier
     * @param options optional parameters for the request
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.terms.getMany
     */
    listTerms(glossaryId: number, options?: GlossariesModel.ListTermsOptions): Promise<ResponseList<GlossariesModel.Term>>;
    /**
     * @param glossaryId glossary identifier
     * @param userId list user glossaries
     * @param limit maximum number of items to retrieve (default 25)
     * @param offset starting offset in the collection (default 0)
     * @param languageId term language identifier
     * @param translationOfTermId filter terms by termId
     * @param conceptId filter terms by conceptId
     * @deprecated optional parameters should be passed through an object
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.terms.getMany
     */
    listTerms(glossaryId: number, userId?: number, limit?: number, offset?: number, languageId?: string, translationOfTermId?: number, conceptId?: number): Promise<ResponseList<GlossariesModel.Term>>;
    /**
     * @param glossaryId glossary identifier
     * @param request request body
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.terms.post
     */
    addTerm(glossaryId: number, request: GlossariesModel.CreateTermRequest): Promise<ResponseObject<GlossariesModel.Term>>;
    /**
     * @param glossaryId glossary identifier
     * @param options optional parameters for the request
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.terms.deleteMany
     */
    clearGlossary(glossaryId: number, options?: GlossariesModel.ClearGlossaryOptions): Promise<ResponseObject<GlossariesModel.Term>>;
    /**
     * @param glossaryId glossary identifier
     * @param languageId languageId identifier
     * @param translationOfTermId term translation identifier
     * @param conceptId concept identifier
     * @deprecated optional parameters should be passed through an object
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.terms.deleteMany
     */
    clearGlossary(glossaryId: number, languageId?: number, translationOfTermId?: number, conceptId?: number): Promise<ResponseObject<GlossariesModel.Term>>;
    /**
     * @param glossaryId glossary identifier
     * @param termId term identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.terms.get
     */
    getTerm(glossaryId: number, termId: number): Promise<ResponseObject<GlossariesModel.Term>>;
    /**
     * @param glossaryId glossary identifier
     * @param termId term identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.terms.delete
     */
    deleteTerm(glossaryId: number, termId: number): Promise<void>;
    /**
     * @param glossaryId glossary identifier
     * @param termId term identifier
     * @param request request body
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.terms.patch
     */
    editTerm(glossaryId: number, termId: number, request: PatchRequest[]): Promise<ResponseObject<GlossariesModel.Term>>;
    /**
     * @param glossaryId glossary identifier
     * @param options optional parameters for the request
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.concepts.getMany
     */
    listConcepts(glossaryId: number, options?: {
        orderBy?: string;
    } & PaginationOptions): Promise<ResponseList<GlossariesModel.Concept>>;
    /**
     * @param glossaryId glossary identifier
     * @param conceptId concept identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.concepts.get
     */
    getConcept(glossaryId: number, conceptId: number): Promise<ResponseObject<GlossariesModel.Concept>>;
    /**
     * @param glossaryId glossary identifier
     * @param conceptId concept identifier
     * @param request request body
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.concepts.put
     */
    updateConcept(glossaryId: number, conceptId: number, request: GlossariesModel.UpdateConceptRequest): Promise<ResponseObject<GlossariesModel.Concept>>;
    /**
     * @param glossaryId glossary identifier
     * @param conceptId concept identifier
     * @see https://developer.crowdin.com/api/v2/#operation/api.glossaries.concepts.delete
     */
    deleteConcept(glossaryId: number, conceptId: number): Promise<void>;
    /**
     * @param projectId project identifier
     * @param request request body
     * @see https://developer.crowdin.com/api/v2/#operation/api.projects.glossaries.concordance.post
     */
    concordanceSearch(projectId: number, request: GlossariesModel.ConcordanceSearchRequest): Promise<ResponseList<GlossariesModel.ConcordanceSearchResponse>>;
}
export declare namespace GlossariesModel {
    interface Glossary {
        id: number;
        name: string;
        groupId: number;
        userId: number;
        terms: number;
        languageId: string;
        languageIds: string[];
        defaultProjectIds: number[];
        projectIds: number[];
        webUrl: string;
        createdAt: string;
    }
    interface CreateGlossaryRequest {
        name: string;
        languageId: string;
        groupId?: number;
    }
    type ExportField = 'term' | 'description' | 'partOfSpeech' | 'type' | 'status' | 'gender' | 'note' | 'url' | 'conceptDefinition' | 'conceptSubject' | 'conceptNote' | 'conceptUrl' | 'conceptFigure';
    interface ExportGlossaryRequest {
        format?: GlossaryFormat;
        exportFields?: ExportField[];
    }
    interface GlossaryExportStatusAttribute {
        format: string;
        exportFields: ExportField[];
    }
    interface GlossaryImportStatusAttribute {
        storageId: number;
        scheme: unknown;
        firstLineContainsHeader: boolean;
    }
    interface GlossaryFile {
        storageId: number;
        scheme?: GlossaryFileScheme;
        firstLineContainsHeader?: boolean;
    }
    interface ListTermsOptions extends PaginationOptions {
        userId?: number;
        languageId?: string;
        conceptId?: number;
        orderBy?: string;
        croql?: string;
        /**
         * @deprecated
         */
        translationOfTermId?: number;
    }
    interface Term {
        id: number;
        userId: number;
        glossaryId: number;
        languageId: string;
        text: string;
        description: string;
        partOfSpeech: PartOfSpeech;
        status: Status;
        type: Type;
        gender: Gender;
        note: string;
        url: string;
        conceptId: number;
        lemma: string;
        createdAt: string;
        updatedAt: string;
    }
    interface CreateTermRequest {
        languageId: string;
        text: string;
        description?: string;
        partOfSpeech?: PartOfSpeech;
        status?: Status;
        type?: Type;
        gender?: Gender;
        note?: string;
        url?: string;
        conceptId?: number;
        /**
         * @deprecated
         */
        translationOfTermId?: number;
    }
    interface ConcordanceSearchRequest extends PaginationOptions {
        sourceLanguageId: string;
        targetLanguageId: string;
        expressions: string[];
        /**
         * @deprecated
         */
        expression?: string;
    }
    interface ConcordanceSearchResponse {
        glossary: Glossary;
        concept: Concept;
        sourceTerms: Term[];
        targetTerms: Term[];
    }
    type Status = 'preferred' | 'admitted' | 'not recommended' | 'obsolete';
    type Type = 'full form' | 'acronym' | 'abbreviation' | 'short form' | 'phrase' | 'variant';
    type Gender = 'masculine' | 'feminine' | 'neuter' | 'other';
    type GlossaryFormat = 'tbx' | 'tbx_v3' | 'csv' | 'xlsx';
    interface GlossaryFileScheme {
        [key: string]: number;
    }
    type PartOfSpeech = 'adjective' | 'adposition' | 'adverb' | 'auxiliary' | 'coordinating conjunction' | 'determiner' | 'interjection' | 'noun' | 'numeral' | 'particle' | 'pronoun' | 'proper noun' | 'subordinating conjunction' | 'verb' | 'other';
    interface ListGlossariesOptions extends PaginationOptions {
        groupId?: number;
        userId?: number;
        orderBy?: string;
    }
    interface ClearGlossaryOptions {
        languageId?: number;
        /**
         * @deprecated
         */
        translationOfTermId?: number;
        conceptId?: number;
    }
    interface Concept {
        id: number;
        userId: number;
        glossaryId: number;
        subject: string;
        definition: string;
        translatable: boolean;
        note: string;
        url: string;
        figure: string;
        languagesDetails: LanguageDetails[];
        createdAt: string;
        updatedAt: string;
    }
    interface LanguageDetails {
        languageId: string;
        userId: number;
        definition: string;
        note: string;
        createdAt: string;
        updatedAt: string;
    }
    interface UpdateConceptRequest {
        subject?: string;
        definition?: string;
        translatable?: boolean;
        note?: string;
        url?: string;
        figure?: string;
        languagesDetails?: {
            languageId: string;
            definition: string;
            note?: string;
        }[];
    }
}