@markupai/api 1.2.0 → 1.3.0

package/README.md

@@ -7,24 +7,6 @@ The official Markup AI SDK for interacting with the Markup AI API.
 
 ## Table of Contents
 
-- [Table of Contents](#table-of-contents)
-- [Installation](#installation)
-- [Reference](#reference)
-- [Usage](#usage)
-- [Request and Response Types](#request-and-response-types)
-- [Exception Handling](#exception-handling)
-- [Advanced](#advanced)
-    - [Additional Headers](#additional-headers)
-    - [Additional Query String Parameters](#additional-query-string-parameters)
-    - [Retries](#retries)
-    - [Timeouts](#timeouts)
-    - [Aborting Requests](#aborting-requests)
-    - [Access Raw Response Data](#access-raw-response-data)
-    - [Runtime Compatibility](#runtime-compatibility)
-- [Contributing](#contributing)
-
-## Table of Contents
-
 - [Installation](#installation)
 - [Reference](#reference)
 - [Usage](#usage)

package/dist/cjs/Client.d.ts

@@ -7,6 +7,7 @@ import { StyleGuides } from "./api/resources/styleGuides/client/Client.js";
 import { StyleChecks } from "./api/resources/styleChecks/client/Client.js";
 import { StyleSuggestions } from "./api/resources/styleSuggestions/client/Client.js";
 import { StyleRewrites } from "./api/resources/styleRewrites/client/Client.js";
+import { Terminology } from "./api/resources/terminology/client/Client.js";
 export declare namespace MarkupAIClient {
     interface Options {
         environment?: core.Supplier<environments.MarkupAIEnvironment | string>;
@@ -36,9 +37,11 @@ export declare class MarkupAIClient {
     protected _styleChecks: StyleChecks | undefined;
     protected _styleSuggestions: StyleSuggestions | undefined;
     protected _styleRewrites: StyleRewrites | undefined;
+    protected _terminology: Terminology | undefined;
     constructor(_options: MarkupAIClient.Options);
     get styleGuides(): StyleGuides;
     get styleChecks(): StyleChecks;
     get styleSuggestions(): StyleSuggestions;
     get styleRewrites(): StyleRewrites;
+    get terminology(): Terminology;
 }

package/dist/cjs/Client.js

@@ -43,13 +43,14 @@ const Client_js_1 = require("./api/resources/styleGuides/client/Client.js");
 const Client_js_2 = require("./api/resources/styleChecks/client/Client.js");
 const Client_js_3 = require("./api/resources/styleSuggestions/client/Client.js");
 const Client_js_4 = require("./api/resources/styleRewrites/client/Client.js");
+const Client_js_5 = require("./api/resources/terminology/client/Client.js");
 class MarkupAIClient {
     constructor(_options) {
         this._options = Object.assign(Object.assign({}, _options), { headers: (0, headers_js_1.mergeHeaders)({
                 "X-Fern-Language": "JavaScript",
                 "X-Fern-SDK-Name": "@markupai/api",
-                "X-Fern-SDK-Version": "1.2.0",
-                "User-Agent": "@markupai/api/1.2.0",
+                "X-Fern-SDK-Version": "1.3.0",
+                "User-Agent": "@markupai/api/1.3.0",
                 "X-Fern-Runtime": core.RUNTIME.type,
                 "X-Fern-Runtime-Version": core.RUNTIME.version,
             }, _options === null || _options === void 0 ? void 0 : _options.headers) });
@@ -70,5 +71,9 @@ class MarkupAIClient {
         var _a;
         return ((_a = this._styleRewrites) !== null && _a !== void 0 ? _a : (this._styleRewrites = new Client_js_4.StyleRewrites(this._options)));
     }
+    get terminology() {
+        var _a;
+        return ((_a = this._terminology) !== null && _a !== void 0 ? _a : (this._terminology = new Client_js_5.Terminology(this._options)));
+    }
 }
 exports.MarkupAIClient = MarkupAIClient;

package/dist/cjs/api/resources/index.d.ts

@@ -2,7 +2,9 @@ export * as styleGuides from "./styleGuides/index.js";
 export * as styleChecks from "./styleChecks/index.js";
 export * as styleSuggestions from "./styleSuggestions/index.js";
 export * as styleRewrites from "./styleRewrites/index.js";
+export * as terminology from "./terminology/index.js";
 export * from "./styleGuides/client/requests/index.js";
 export * from "./styleChecks/client/requests/index.js";
 export * from "./styleSuggestions/client/requests/index.js";
 export * from "./styleRewrites/client/requests/index.js";
+export * from "./terminology/client/requests/index.js";

package/dist/cjs/api/resources/index.js

@@ -36,12 +36,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.styleRewrites = exports.styleSuggestions = exports.styleChecks = exports.styleGuides = void 0;
+exports.terminology = exports.styleRewrites = exports.styleSuggestions = exports.styleChecks = exports.styleGuides = void 0;
 exports.styleGuides = __importStar(require("./styleGuides/index.js"));
 exports.styleChecks = __importStar(require("./styleChecks/index.js"));
 exports.styleSuggestions = __importStar(require("./styleSuggestions/index.js"));
 exports.styleRewrites = __importStar(require("./styleRewrites/index.js"));
+exports.terminology = __importStar(require("./terminology/index.js"));
 __exportStar(require("./styleGuides/client/requests/index.js"), exports);
 __exportStar(require("./styleChecks/client/requests/index.js"), exports);
 __exportStar(require("./styleSuggestions/client/requests/index.js"), exports);
 __exportStar(require("./styleRewrites/client/requests/index.js"), exports);
+__exportStar(require("./terminology/client/requests/index.js"), exports);

package/dist/cjs/api/resources/styleGuides/client/Client.d.ts

@@ -105,10 +105,10 @@ export declare class StyleGuides {
     deleteStyleGuide(styleGuideId: string, requestOptions?: StyleGuides.RequestOptions): core.HttpResponsePromise<void>;
     private __deleteStyleGuide;
     /**
-     * Update the name of an existing style guide.
+     * Update the name and/or terminology domain IDs of an existing style guide.
      *
      * @param {string} styleGuideId - The ID of the style guide.
-     * @param {MarkupAI.BodyUpdateStyleGuideV1StyleGuidesStyleGuideIdPatch} request
+     * @param {MarkupAI.BodyStyleGuidesUpdateStyleGuide} request
      * @param {StyleGuides.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link MarkupAI.UnauthorizedError}
@@ -119,11 +119,9 @@ export declare class StyleGuides {
      * @throws {@link MarkupAI.InternalServerError}
      *
      * @example
-     *     await client.styleGuides.updateStyleGuide("style_guide_id", {
-     *         name: "name"
-     *     })
+     *     await client.styleGuides.updateStyleGuide("style_guide_id")
      */
-    updateStyleGuide(styleGuideId: string, request: MarkupAI.BodyUpdateStyleGuideV1StyleGuidesStyleGuideIdPatch, requestOptions?: StyleGuides.RequestOptions): core.HttpResponsePromise<MarkupAI.StyleGuideResponse>;
+    updateStyleGuide(styleGuideId: string, request?: MarkupAI.BodyStyleGuidesUpdateStyleGuide, requestOptions?: StyleGuides.RequestOptions): core.HttpResponsePromise<MarkupAI.StyleGuideResponse>;
     private __updateStyleGuide;
     protected _getAuthorizationHeader(): Promise<string>;
 }

package/dist/cjs/api/resources/styleGuides/client/Client.js

@@ -157,6 +157,11 @@ class StyleGuides {
             if (request.base_style_guide != null) {
                 _request.append("base_style_guide", request.base_style_guide);
             }
+            if (request.terminology_domain_ids != null) {
+                for (const _item of request.terminology_domain_ids) {
+                    _request.append("terminology_domain_ids", _item);
+                }
+            }
             const _maybeEncodedRequest = yield _request.getRequest();
             let _headers = (0, headers_js_1.mergeHeaders)((_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)(Object.assign({ Authorization: yield this._getAuthorizationHeader() }, _maybeEncodedRequest.headers)), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
             const _response = yield ((_b = this._options.fetcher) !== null && _b !== void 0 ? _b : core.fetcher)({
@@ -356,10 +361,10 @@ class StyleGuides {
         });
     }
     /**
-     * Update the name of an existing style guide.
+     * Update the name and/or terminology domain IDs of an existing style guide.
      *
      * @param {string} styleGuideId - The ID of the style guide.
-     * @param {MarkupAI.BodyUpdateStyleGuideV1StyleGuidesStyleGuideIdPatch} request
+     * @param {MarkupAI.BodyStyleGuidesUpdateStyleGuide} request
      * @param {StyleGuides.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link MarkupAI.UnauthorizedError}
@@ -370,15 +375,13 @@ class StyleGuides {
      * @throws {@link MarkupAI.InternalServerError}
      *
      * @example
-     *     await client.styleGuides.updateStyleGuide("style_guide_id", {
-     *         name: "name"
-     *     })
+     *     await client.styleGuides.updateStyleGuide("style_guide_id")
      */
-    updateStyleGuide(styleGuideId, request, requestOptions) {
+    updateStyleGuide(styleGuideId, request = {}, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__updateStyleGuide(styleGuideId, request, requestOptions));
     }
-    __updateStyleGuide(styleGuideId, request, requestOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
+    __updateStyleGuide(styleGuideId_1) {
+        return __awaiter(this, arguments, void 0, function* (styleGuideId, request = {}, requestOptions) {
             var _a, _b, _c, _d;
             let _headers = (0, headers_js_1.mergeHeaders)((_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ Authorization: yield this._getAuthorizationHeader() }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
             const _response = yield ((_b = this._options.fetcher) !== null && _b !== void 0 ? _b : core.fetcher)({

package/dist/cjs/api/resources/styleGuides/client/requests/BodyStyleGuidesUpdateStyleGuide.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+/**
+ * @example
+ *     {}
+ */
+export interface BodyStyleGuidesUpdateStyleGuide {
+    /** The name of the style guide. */
+    name?: string;
+    /** List of domain IDs to filter terminology searches by. NULL or empty list means no filtering. */
+    terminology_domain_ids?: string[];
+}

package/dist/cjs/api/resources/styleGuides/client/requests/StyleGuideRequestBody.d.ts

@@ -17,4 +17,6 @@ export interface StyleGuideRequestBody {
     name: string;
     /** The base style guide to extend (AP, Chicago, or Microsoft). If not provided, the style guide will be created from scratch. */
     base_style_guide?: MarkupAI.BaseStyleGuideType;
+    /** List of domain IDs to filter terminology searches by. NULL or empty list means no filtering. */
+    terminology_domain_ids?: string[];
 }

package/dist/cjs/api/resources/styleGuides/client/requests/index.d.ts

@@ -1,2 +1,2 @@
 export { type StyleGuideRequestBody } from "./StyleGuideRequestBody.js";
-export { type BodyUpdateStyleGuideV1StyleGuidesStyleGuideIdPatch } from "./BodyUpdateStyleGuideV1StyleGuidesStyleGuideIdPatch.js";
+export { type BodyStyleGuidesUpdateStyleGuide } from "./BodyStyleGuidesUpdateStyleGuide.js";

package/dist/cjs/api/resources/terminology/client/Client.d.ts

@@ -0,0 +1,333 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as environments from "../../../../environments.js";
+import * as core from "../../../../core/index.js";
+import * as MarkupAI from "../../../index.js";
+export declare namespace Terminology {
+    interface Options {
+        environment?: core.Supplier<environments.MarkupAIEnvironment | string>;
+        /** Specify a custom URL to connect the client to. */
+        baseUrl?: core.Supplier<string>;
+        token: core.Supplier<core.BearerToken>;
+        /** Additional headers to include in requests. */
+        headers?: Record<string, string | core.Supplier<string | null | undefined> | null | undefined>;
+        fetcher?: core.FetchFunction;
+    }
+    interface RequestOptions {
+        /** The maximum time to wait for a response in seconds. */
+        timeoutInSeconds?: number;
+        /** The number of times to retry the request. Defaults to 2. */
+        maxRetries?: number;
+        /** A hook to abort the request. */
+        abortSignal?: AbortSignal;
+        /** Additional query string parameters to include in the request. */
+        queryParams?: Record<string, unknown>;
+        /** Additional headers to include in the request. */
+        headers?: Record<string, string | core.Supplier<string | null | undefined> | null | undefined>;
+    }
+}
+/**
+ * Manage term sets and terms.
+ */
+export declare class Terminology {
+    protected readonly _options: Terminology.Options;
+    constructor(_options: Terminology.Options);
+    /**
+     * Exports all term sets, terms and domains to CSV. The exported CSV follows the same format as the CSV import.
+     *
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.exportTerminology()
+     */
+    exportTerminology(requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<unknown>;
+    private __exportTerminology;
+    /**
+     * Uploads a CSV or ACTIF XML file and imports terminology.
+     *
+     * **CSV Format Requirements:**
+     * - CSV must include columns: Prohibited, Preferred, Context-Dependent, Instructions, Domains
+     * - The first row must contain the column headers in the exact same order as shown above
+     * - Multiple values within a single cell should be separated by semicolons with a space (e.g., term1; term2; term3)
+     * - Empty cells are allowed
+     * - The CSV import format is the same as the CSV export format.
+     *
+     * @param {MarkupAI.BodyTerminologyImportTerminology} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     import { createReadStream } from "fs";
+     *     await client.terminology.importTerminology({
+     *         file: fs.createReadStream("/path/to/your/file"),
+     *         delete_existing: true
+     *     })
+     */
+    importTerminology(request: MarkupAI.BodyTerminologyImportTerminology, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.ImportSummary>;
+    private __importTerminology;
+    /**
+     * Searches the text for relevant terminology and returns matched term sets.
+     *
+     * Term sets are matched if any word sequence (up to 5 words) in the text is similar to one of the terms of the term set.
+     * The similarity measure used is a trigram similarity of 0.5 or higher between the word sequence and the term.
+     *
+     * @param {MarkupAI.TerminologySearchTerminologyRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.searchTerminology({
+     *         query: "query"
+     *     })
+     */
+    searchTerminology(request: MarkupAI.TerminologySearchTerminologyRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.TerminologySearchResponse>;
+    private __searchTerminology;
+    /**
+     * Get a pageable list of term sets with all their associated terms and domains.
+     *
+     * The search filter searches the term set instructions and term text fields.
+     *
+     * @param {MarkupAI.TerminologyListTermSetsRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.listTermSets({
+     *         page: 1,
+     *         page_size: 1,
+     *         search_term: "search_term"
+     *     })
+     */
+    listTermSets(request?: MarkupAI.TerminologyListTermSetsRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.PaginatedTermSetsResponse>;
+    private __listTermSets;
+    /**
+     * Create a new term set. Terms and domains are linked to term sets.
+     * The term set instructions text will be used to determine whether a term should be flagged in the text and what the term replacement should be.
+     *
+     * @param {MarkupAI.TermSetCreateRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.createTermSet({
+     *         instructions: "instructions"
+     *     })
+     */
+    createTermSet(request: MarkupAI.TermSetCreateRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.TermSetResponse>;
+    private __createTermSet;
+    /**
+     * @param {string} termSetId - UUID of the term set
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.getTermSet("term_set_id")
+     */
+    getTermSet(termSetId: string, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.TermSetWithTerms>;
+    private __getTermSet;
+    /**
+     * @param {string} termSetId - UUID of the term set
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.deleteTermSet("term_set_id")
+     */
+    deleteTermSet(termSetId: string, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<void>;
+    private __deleteTermSet;
+    /**
+     * @param {string} termSetId - UUID of the term set
+     * @param {MarkupAI.TermSetUpdateRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.updateTermSet("term_set_id")
+     */
+    updateTermSet(termSetId: string, request?: MarkupAI.TermSetUpdateRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.TermSetResponse>;
+    private __updateTermSet;
+    /**
+     * Create terms that should be matched in the text. The term types are:
+     *
+     * * **preferred**: this is the preferred term for the associated term set
+     * * **prohibited**: this term should not be used to talk about the term set
+     * * **context_dependent**: this term is correct in certain cases, but incorrect in others, the instructions field of the term set should explain when the term is correct and when it is incorrect
+     *
+     * @param {string} termSetId - UUID of the term set
+     * @param {MarkupAI.TermCreateRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.createTerm("term_set_id", {
+     *         term: "term",
+     *         type: "preferred"
+     *     })
+     */
+    createTerm(termSetId: string, request: MarkupAI.TermCreateRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.TermResponse>;
+    private __createTerm;
+    /**
+     * @param {string} termSetId - UUID of the term set
+     * @param {string} termId - UUID of the term
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.getTerm("term_set_id", "term_id")
+     */
+    getTerm(termSetId: string, termId: string, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.TermResponse>;
+    private __getTerm;
+    /**
+     * @param {string} termSetId - UUID of the term set
+     * @param {string} termId - UUID of the term
+     * @param {MarkupAI.TermUpdateRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.updateTerm("term_set_id", "term_id", {
+     *         term: "term",
+     *         type: "preferred"
+     *     })
+     */
+    updateTerm(termSetId: string, termId: string, request: MarkupAI.TermUpdateRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.TermResponse>;
+    private __updateTerm;
+    /**
+     * @param {string} termSetId - UUID of the term set
+     * @param {string} termId - UUID of the term
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.deleteTerm("term_set_id", "term_id")
+     */
+    deleteTerm(termSetId: string, termId: string, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<void>;
+    private __deleteTerm;
+    /**
+     * @param {MarkupAI.TerminologyListDomainsRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.listDomains({
+     *         page: 1,
+     *         page_size: 1,
+     *         search: "search"
+     *     })
+     */
+    listDomains(request?: MarkupAI.TerminologyListDomainsRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.PaginatedDomainsResponse>;
+    private __listDomains;
+    /**
+     * @param {MarkupAI.DomainCreateRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.createDomain({
+     *         name: "name"
+     *     })
+     */
+    createDomain(request: MarkupAI.DomainCreateRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.DomainResponse>;
+    private __createDomain;
+    /**
+     * @param {string} domainId - UUID of the domain
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.getDomain("domain_id")
+     */
+    getDomain(domainId: string, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.DomainResponse>;
+    private __getDomain;
+    /**
+     * @param {string} domainId - UUID of the domain
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.deleteDomain("domain_id")
+     */
+    deleteDomain(domainId: string, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<void>;
+    private __deleteDomain;
+    /**
+     * @param {string} domainId - UUID of the domain
+     * @param {MarkupAI.DomainUpdateRequest} request
+     * @param {Terminology.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link MarkupAI.UnauthorizedError}
+     * @throws {@link MarkupAI.ForbiddenError}
+     * @throws {@link MarkupAI.UnprocessableEntityError}
+     * @throws {@link MarkupAI.InternalServerError}
+     *
+     * @example
+     *     await client.terminology.updateDomain("domain_id")
+     */
+    updateDomain(domainId: string, request?: MarkupAI.DomainUpdateRequest, requestOptions?: Terminology.RequestOptions): core.HttpResponsePromise<MarkupAI.DomainResponse>;
+    private __updateDomain;
+    protected _getAuthorizationHeader(): Promise<string>;
+}