From c45d1e452fe04975144132848bf0aed620cfa88e Mon Sep 17 00:00:00 2001 From: SDKAuto Date: Mon, 11 Dec 2023 03:20:18 +0000 Subject: [PATCH] CodeGen from PR 26702 in Azure/azure-rest-api-specs Merge c14af8ed8cf91c1cac08c74f95c30877ce0d76c8 into 6c4497e6b0aaad8127f2dd50fa8a29aaf68f24e6 --- common/config/rush/pnpm-lock.yaml | 52 +- rush.json | 7 +- sdk/purview/ci.yml | 2 + .../purview-datamap-rest/.eslintrc.json | 11 + sdk/purview/purview-datamap-rest/CHANGELOG.md | 3 + sdk/purview/purview-datamap-rest/README.md | 62 + .../purview-datamap-rest/api-extractor.json | 31 + .../purview-datamap-rest/karma.conf.js | 133 + sdk/purview/purview-datamap-rest/package.json | 118 + .../review/purview-datamap.api.md | 4709 +++++++++++++++++ .../src/clientDefinitions.ts | 1590 ++++++ sdk/purview/purview-datamap-rest/src/index.ts | 15 + .../purview-datamap-rest/src/isUnexpected.ts | 1091 ++++ .../purview-datamap-rest/src/logger.ts | 5 + .../purview-datamap-rest/src/models.ts | 1464 +++++ .../purview-datamap-rest/src/outputModels.ts | 1622 ++++++ .../purview-datamap-rest/src/parameters.ts | 1023 ++++ .../src/purviewDataMapClient.ts | 49 + .../purview-datamap-rest/src/responses.ts | 1125 ++++ .../src/serializeHelper.ts | 13 + .../test/public/sampleTest.spec.ts | 23 + .../test/public/utils/env.browser.ts | 2 + .../test/public/utils/env.ts | 6 + .../test/public/utils/recordedClient.ts | 29 + .../purview-datamap-rest/tsconfig.json | 11 + .../purview-datamap-rest/tsp-location.yaml | 5 + 26 files changed, 13198 insertions(+), 3 deletions(-) create mode 100644 sdk/purview/purview-datamap-rest/.eslintrc.json create mode 100644 sdk/purview/purview-datamap-rest/CHANGELOG.md create mode 100644 sdk/purview/purview-datamap-rest/README.md create mode 100644 sdk/purview/purview-datamap-rest/api-extractor.json create mode 100644 sdk/purview/purview-datamap-rest/karma.conf.js create mode 100644 sdk/purview/purview-datamap-rest/package.json create mode 100644 sdk/purview/purview-datamap-rest/review/purview-datamap.api.md create mode 100644 sdk/purview/purview-datamap-rest/src/clientDefinitions.ts create mode 100644 sdk/purview/purview-datamap-rest/src/index.ts create mode 100644 sdk/purview/purview-datamap-rest/src/isUnexpected.ts create mode 100644 sdk/purview/purview-datamap-rest/src/logger.ts create mode 100644 sdk/purview/purview-datamap-rest/src/models.ts create mode 100644 sdk/purview/purview-datamap-rest/src/outputModels.ts create mode 100644 sdk/purview/purview-datamap-rest/src/parameters.ts create mode 100644 sdk/purview/purview-datamap-rest/src/purviewDataMapClient.ts create mode 100644 sdk/purview/purview-datamap-rest/src/responses.ts create mode 100644 sdk/purview/purview-datamap-rest/src/serializeHelper.ts create mode 100644 sdk/purview/purview-datamap-rest/test/public/sampleTest.spec.ts create mode 100644 sdk/purview/purview-datamap-rest/test/public/utils/env.browser.ts create mode 100644 sdk/purview/purview-datamap-rest/test/public/utils/env.ts create mode 100644 sdk/purview/purview-datamap-rest/test/public/utils/recordedClient.ts create mode 100644 sdk/purview/purview-datamap-rest/tsconfig.json create mode 100644 sdk/purview/purview-datamap-rest/tsp-location.yaml diff --git a/common/config/rush/pnpm-lock.yaml b/common/config/rush/pnpm-lock.yaml index 9f3fbacf7584..4e9343c3cd0b 100644 --- a/common/config/rush/pnpm-lock.yaml +++ b/common/config/rush/pnpm-lock.yaml @@ -1019,6 +1019,9 @@ dependencies: '@rush-temp/purview-catalog': specifier: file:./projects/purview-catalog.tgz version: file:projects/purview-catalog.tgz + '@rush-temp/purview-datamap': + specifier: file:./projects/purview-datamap.tgz + version: file:projects/purview-datamap.tgz '@rush-temp/purview-scanning': specifier: file:./projects/purview-scanning.tgz version: file:projects/purview-scanning.tgz @@ -17252,7 +17255,7 @@ packages: dev: false file:projects/core-rest-pipeline.tgz: - resolution: {integrity: sha512-qQLlASe7L1wkWCK0onmD56p8UV+w6TvtdOH+MkMPugjrUMQAgbyCUZLm6eKlnjEYGLwwjmRuv034XG8PbRc9Ww==, tarball: file:projects/core-rest-pipeline.tgz} + resolution: {integrity: sha512-PV5E9f7Vdto/8RUYJn+hhwAGuEOMlf5KEMlEaYmwwRWFnT4zRGk/pohg3lhbuDBEWjwAub6CAIzacvybAvsqZg==, tarball: file:projects/core-rest-pipeline.tgz} name: '@rush-temp/core-rest-pipeline' version: 0.0.0 dependencies: @@ -19983,6 +19986,51 @@ packages: - utf-8-validate dev: false + file:projects/purview-datamap.tgz: + resolution: {integrity: sha512-7qhkI8gc7YZmGGPsPMYgDQd88jBCmppTGoYQhjFI2eBnILUIh8r1WCPTHYWO62CkllvImK/P/1Q3ETB/KYVgUg==, tarball: file:projects/purview-datamap.tgz} + name: '@rush-temp/purview-datamap' + version: 0.0.0 + dependencies: + '@azure/identity': 3.4.1 + '@microsoft/api-extractor': 7.38.3(@types/node@18.19.2) + '@types/chai': 4.3.11 + '@types/mocha': 10.0.6 + '@types/node': 18.19.2 + autorest: 3.7.1 + c8: 8.0.1 + chai: 4.3.10 + cross-env: 7.0.3 + dotenv: 16.3.1 + eslint: 8.55.0 + esm: 3.2.25 + karma: 6.4.2(debug@4.3.4) + karma-chrome-launcher: 3.2.0 + karma-coverage: 2.2.1 + karma-env-preprocessor: 0.1.1 + karma-firefox-launcher: 2.1.2 + karma-junit-reporter: 2.0.1(karma@6.4.2) + karma-mocha: 2.0.1 + karma-mocha-reporter: 2.2.5(karma@6.4.2) + karma-source-map-support: 1.4.0 + karma-sourcemap-loader: 0.4.0 + mkdirp: 2.1.6 + mocha: 10.2.0 + mocha-junit-reporter: 1.23.3(mocha@10.2.0) + prettier: 2.8.8 + rimraf: 5.0.5 + source-map-support: 0.5.21 + ts-node: 10.9.1(@types/node@18.19.2)(typescript@5.2.2) + tslib: 2.6.2 + typescript: 5.2.2 + transitivePeerDependencies: + - '@swc/core' + - '@swc/wasm' + - bufferutil + - debug + - supports-color + - utf-8-validate + dev: false + file:projects/purview-scanning.tgz: resolution: {integrity: sha512-2+35NfJ/9IqADRihULcq7jPNX0LLp2COt0nNp5uX6DcZhIA1pRTxFGGyMxsXdvi7VWjxGGxXv9GKsmpBdyCQKw==, tarball: file:projects/purview-scanning.tgz} name: '@rush-temp/purview-scanning' @@ -20303,7 +20351,7 @@ packages: dev: false file:projects/search-documents.tgz: - resolution: {integrity: sha512-7ydGCD7a/xwpSa8juyxMibTpjJ7vK+9X4JlhI9p/45Dz0o1leumfdBGS+ag/qM20eH6KeLDkLXVvYddI68Pa6w==, tarball: file:projects/search-documents.tgz} + resolution: {integrity: sha512-9k4LApml/j2nEyblv8gd9mS02fzEjFmskLW7HONO5Ft8L9DdWk1ndUAGpqx1ggbol07QnBWAo24j3eIDCQHnGQ==, tarball: file:projects/search-documents.tgz} name: '@rush-temp/search-documents' version: 0.0.0 dependencies: diff --git a/rush.json b/rush.json index 4dfdd8403d77..366cd6e1a401 100644 --- a/rush.json +++ b/rush.json @@ -2147,6 +2147,11 @@ "packageName": "@azure/arm-networkanalytics", "projectFolder": "sdk/networkanalytics/arm-networkanalytics", "versionPolicyName": "management" + }, + { + "packageName": "@azure-rest/purview-datamap", + "projectFolder": "sdk/purview/purview-datamap-rest", + "versionPolicyName": "client" } ] -} +} \ No newline at end of file diff --git a/sdk/purview/ci.yml b/sdk/purview/ci.yml index 619246f52ca1..ec18369d6f5d 100644 --- a/sdk/purview/ci.yml +++ b/sdk/purview/ci.yml @@ -42,3 +42,5 @@ extends: safeName: azurerestpurviewsharing - name: azure-rest-purview-workflow safeName: azurerestpurviewworkflow + - name: azure-rest-purview-datamap + safeName: azurerestpurviewdatamap diff --git a/sdk/purview/purview-datamap-rest/.eslintrc.json b/sdk/purview/purview-datamap-rest/.eslintrc.json new file mode 100644 index 000000000000..619797ac39b6 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/.eslintrc.json @@ -0,0 +1,11 @@ +{ + "plugins": ["@azure/azure-sdk"], + "extends": ["plugin:@azure/azure-sdk/azure-sdk-base"], + "rules": { + "@azure/azure-sdk/ts-modules-only-named": "warn", + "@azure/azure-sdk/ts-apiextractor-json-types": "warn", + "@azure/azure-sdk/ts-package-json-types": "warn", + "@azure/azure-sdk/ts-package-json-engine-is-present": "warn", + "tsdoc/syntax": "warn" + } +} diff --git a/sdk/purview/purview-datamap-rest/CHANGELOG.md b/sdk/purview/purview-datamap-rest/CHANGELOG.md new file mode 100644 index 000000000000..ba3f1b90a8be --- /dev/null +++ b/sdk/purview/purview-datamap-rest/CHANGELOG.md @@ -0,0 +1,3 @@ +## 1.0.0-beta.1 (2023-12-11) + + - Initial Release diff --git a/sdk/purview/purview-datamap-rest/README.md b/sdk/purview/purview-datamap-rest/README.md new file mode 100644 index 000000000000..8719b426acc6 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/README.md @@ -0,0 +1,62 @@ +# Azure PurviewDataMap REST client library for JavaScript + +Purview Data Map Service is a fully managed cloud service whose users can +discover the data sources they need and understand the data sources they find. +At the same time, Data Map helps organizations get more value from their +existing investments. This spec defines REST API of Purview Data Map Service. + +**Please rely heavily on our [REST client docs](https://github.com/Azure/azure-sdk-for-js/blob/main/documentation/rest-clients.md) to use this library** + +Key links: + +- [Source code](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/purview/purview-datamap-rest) +- [Package (NPM)](https://www.npmjs.com/package/@azure-rest/purview-datamap) +- [API reference documentation](https://docs.microsoft.com/javascript/api/@azure-rest/purview-datamap?view=azure-node-preview) +- [Samples](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/purview/purview-datamap-rest/samples) + +## Getting started + +### Currently supported environments + +- LTS versions of Node.js + +### Prerequisites + +- You must have an [Azure subscription](https://azure.microsoft.com/free/) to use this package. + +### Install the `@azure-rest/purview-datamap` package + +Install the Azure PurviewDataMap REST client REST client library for JavaScript with `npm`: + +```bash +npm install @azure-rest/purview-datamap +``` + +### Create and authenticate a `PurviewDataMapClient` + +To use an [Azure Active Directory (AAD) token credential](https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity/samples/AzureIdentityExamples.md#authenticating-with-a-pre-fetched-access-token), +provide an instance of the desired credential type obtained from the +[@azure/identity](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/identity/identity#credentials) library. + +To authenticate with AAD, you must first `npm` install [`@azure/identity`](https://www.npmjs.com/package/@azure/identity) + +After setup, you can choose which type of [credential](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/identity/identity#credentials) from `@azure/identity` to use. +As an example, [DefaultAzureCredential](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/identity/identity#defaultazurecredential) +can be used to authenticate the client. + +Set the values of the client ID, tenant ID, and client secret of the AAD application as environment variables: +AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET + +## Troubleshooting + +### Logging + +Enabling logging may help uncover useful information about failures. In order to see a log of HTTP requests and responses, set the `AZURE_LOG_LEVEL` environment variable to `info`. Alternatively, logging can be enabled at runtime by calling `setLogLevel` in the `@azure/logger`: + +```javascript +const { setLogLevel } = require("@azure/logger"); + +setLogLevel("info"); +``` + +For more detailed instructions on how to enable logs, you can look at the [@azure/logger package docs](https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/core/logger). diff --git a/sdk/purview/purview-datamap-rest/api-extractor.json b/sdk/purview/purview-datamap-rest/api-extractor.json new file mode 100644 index 000000000000..f2990c5c95f4 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/api-extractor.json @@ -0,0 +1,31 @@ +{ + "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json", + "mainEntryPointFilePath": "./types/src/index.d.ts", + "docModel": { + "enabled": true + }, + "apiReport": { + "enabled": true, + "reportFolder": "./review" + }, + "dtsRollup": { + "enabled": true, + "untrimmedFilePath": "", + "publicTrimmedFilePath": "./types/purview-datamap.d.ts" + }, + "messages": { + "tsdocMessageReporting": { + "default": { + "logLevel": "none" + } + }, + "extractorMessageReporting": { + "ae-missing-release-tag": { + "logLevel": "none" + }, + "ae-unresolved-link": { + "logLevel": "none" + } + } + } +} \ No newline at end of file diff --git a/sdk/purview/purview-datamap-rest/karma.conf.js b/sdk/purview/purview-datamap-rest/karma.conf.js new file mode 100644 index 000000000000..a9d5f1b5fc59 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/karma.conf.js @@ -0,0 +1,133 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +// https://github.com/karma-runner/karma-chrome-launcher +process.env.CHROME_BIN = require("puppeteer").executablePath(); +require("dotenv").config(); +const { relativeRecordingsPath } = require("@azure-tools/test-recorder"); +process.env.RECORDINGS_RELATIVE_PATH = relativeRecordingsPath(); + +module.exports = function (config) { + config.set({ + // base path that will be used to resolve all patterns (eg. files, exclude) + basePath: "./", + + // frameworks to use + // available frameworks: https://npmjs.org/browse/keyword/karma-adapter + frameworks: ["source-map-support", "mocha"], + + plugins: [ + "karma-mocha", + "karma-mocha-reporter", + "karma-chrome-launcher", + "karma-firefox-launcher", + "karma-env-preprocessor", + "karma-coverage", + "karma-sourcemap-loader", + "karma-junit-reporter", + "karma-source-map-support", + ], + + // list of files / patterns to load in the browser + files: [ + "dist-test/index.browser.js", + { + pattern: "dist-test/index.browser.js.map", + type: "html", + included: false, + served: true, + }, + ], + + // list of files / patterns to exclude + exclude: [], + + // preprocess matching files before serving them to the browser + // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor + preprocessors: { + "**/*.js": ["sourcemap", "env"], + // IMPORTANT: COMMENT following line if you want to debug in your browsers!! + // Preprocess source file to calculate code coverage, however this will make source file unreadable + // "dist-test/index.js": ["coverage"] + }, + + envPreprocessor: [ + "TEST_MODE", + "ENDPOINT", + "AZURE_CLIENT_SECRET", + "AZURE_CLIENT_ID", + "AZURE_TENANT_ID", + "SUBSCRIPTION_ID", + "RECORDINGS_RELATIVE_PATH", + ], + + // test results reporter to use + // possible values: 'dots', 'progress' + // available reporters: https://npmjs.org/browse/keyword/karma-reporter + reporters: ["mocha", "coverage", "junit"], + + coverageReporter: { + // specify a common output directory + dir: "coverage-browser/", + reporters: [ + { type: "json", subdir: ".", file: "coverage.json" }, + { type: "lcovonly", subdir: ".", file: "lcov.info" }, + { type: "html", subdir: "html" }, + { type: "cobertura", subdir: ".", file: "cobertura-coverage.xml" }, + ], + }, + + junitReporter: { + outputDir: "", // results will be saved as $outputDir/$browserName.xml + outputFile: "test-results.browser.xml", // if included, results will be saved as $outputDir/$browserName/$outputFile + suite: "", // suite will become the package name attribute in xml testsuite element + useBrowserName: false, // add browser name to report and classes names + nameFormatter: undefined, // function (browser, result) to customize the name attribute in xml testcase element + classNameFormatter: undefined, // function (browser, result) to customize the classname attribute in xml testcase element + properties: {}, // key value pair of properties to add to the section of the report + }, + + // web server port + port: 9876, + + // enable / disable colors in the output (reporters and logs) + colors: true, + + // level of logging + // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG + logLevel: config.LOG_INFO, + + // enable / disable watching file and executing tests whenever any file changes + autoWatch: false, + + // --no-sandbox allows our tests to run in Linux without having to change the system. + // --disable-web-security allows us to authenticate from the browser without having to write tests using interactive auth, which would be far more complex. + browsers: ["ChromeHeadlessNoSandbox"], + customLaunchers: { + ChromeHeadlessNoSandbox: { + base: "ChromeHeadless", + flags: ["--no-sandbox", "--disable-web-security"], + }, + }, + + // Continuous Integration mode + // if true, Karma captures browsers, runs the tests and exits + singleRun: false, + + // Concurrency level + // how many browser should be started simultaneous + concurrency: 1, + + browserNoActivityTimeout: 60000000, + browserDisconnectTimeout: 10000, + browserDisconnectTolerance: 3, + + client: { + mocha: { + // change Karma's debug.html to the mocha web reporter + reporter: "html", + timeout: "600000", + }, + }, + }); +}; diff --git a/sdk/purview/purview-datamap-rest/package.json b/sdk/purview/purview-datamap-rest/package.json new file mode 100644 index 000000000000..17b9d5ad04cf --- /dev/null +++ b/sdk/purview/purview-datamap-rest/package.json @@ -0,0 +1,118 @@ +{ + "name": "@azure-rest/purview-datamap", + "sdk-type": "client", + "author": "Microsoft Corporation", + "version": "1.0.0-beta.1", + "description": "Purview DataMap Service\"", + "keywords": [ + "node", + "azure", + "cloud", + "typescript", + "browser", + "isomorphic" + ], + "license": "MIT", + "main": "dist/index.js", + "module": "./dist-esm/src/index.js", + "types": "./types/purview-datamap.d.ts", + "repository": "github:Azure/azure-sdk-for-js", + "bugs": { + "url": "https://github.com/Azure/azure-sdk-for-js/issues" + }, + "files": [ + "dist/", + "dist-esm/src/", + "types/purview-datamap.d.ts", + "README.md", + "LICENSE", + "review/*" + ], + "engines": { + "node": ">=18.0.0" + }, + "scripts": { + "audit": "node ../../../common/scripts/rush-audit.js && rimraf node_modules package-lock.json && npm i --package-lock-only 2>&1 && npm audit", + "build:browser": "tsc -p . && cross-env ONLY_BROWSER=true rollup -c 2>&1", + "build:node": "tsc -p . && cross-env ONLY_NODE=true rollup -c 2>&1", + "build:samples": "echo skipped.", + "build:test": "tsc -p . && dev-tool run bundle", + "build:debug": "tsc -p . && dev-tool run bundle && api-extractor run --local", + "check-format": "prettier --list-different --config ../../../.prettierrc.json --ignore-path ../../../.prettierignore \"src/**/*.ts\" \"*.{js,json}\" \"test/**/*.ts\"", + "clean": "rimraf --glob dist dist-browser dist-esm test-dist temp types *.tgz *.log", + "execute:samples": "echo skipped", + "extract-api": "rimraf review && mkdirp ./review && api-extractor run --local", + "format": "prettier --write --config ../../../.prettierrc.json --ignore-path ../../../.prettierignore \"src/**/*.ts\" \"*.{js,json}\" \"test/**/*.ts\"", + "generate:client": "echo skipped", + "integration-test:browser": "dev-tool run test:browser", + "integration-test:node": "dev-tool run test:node-js-input -- --timeout 5000000 'dist-esm/test/**/*.spec.js'", + "integration-test": "npm run integration-test:node && npm run integration-test:browser", + "lint:fix": "eslint package.json api-extractor.json src test --ext .ts --fix --fix-type [problem,suggestion]", + "lint": "eslint package.json api-extractor.json src test --ext .ts", + "pack": "npm pack 2>&1", + "test:browser": "npm run clean && npm run build:test && npm run unit-test:browser", + "test:node": "npm run clean && npm run build:test && npm run unit-test:node", + "test": "npm run clean && npm run build:test && npm run unit-test", + "unit-test": "npm run unit-test:node && npm run unit-test:browser", + "unit-test:node": "dev-tool run test:node-ts-input -- --timeout 1200000 --exclude 'test/**/browser/*.spec.ts' 'test/**/*.spec.ts'", + "unit-test:browser": "dev-tool run test:browser", + "build": "npm run clean && tsc -p . && dev-tool run bundle && mkdirp ./review && api-extractor run --local" + }, + "sideEffects": false, + "autoPublish": false, + "dependencies": { + "@azure/core-auth": "^1.3.0", + "@azure-rest/core-client": "^1.1.4", + "@azure/core-rest-pipeline": "^1.12.0", + "@azure/logger": "^1.0.0", + "tslib": "^2.2.0" + }, + "devDependencies": { + "@microsoft/api-extractor": "^7.31.1", + "autorest": "latest", + "@types/node": "^18.0.0", + "dotenv": "^16.0.0", + "eslint": "^8.0.0", + "mkdirp": "^2.1.2", + "prettier": "^2.5.1", + "rimraf": "^5.0.0", + "source-map-support": "^0.5.9", + "typescript": "~5.2.0", + "@azure/dev-tool": "^1.0.0", + "@azure/eslint-plugin-azure-sdk": "^3.0.0", + "@azure-tools/test-credential": "^1.0.0", + "@azure/identity": "^3.3.0", + "@azure-tools/test-recorder": "^3.0.0", + "mocha": "^10.0.0", + "esm": "^3.2.18", + "@types/mocha": "^10.0.0", + "mocha-junit-reporter": "^1.18.0", + "cross-env": "^7.0.2", + "@types/chai": "^4.2.8", + "chai": "^4.2.0", + "karma-chrome-launcher": "^3.0.0", + "karma-coverage": "^2.0.0", + "karma-env-preprocessor": "^0.1.1", + "karma-firefox-launcher": "^2.1.2", + "karma-junit-reporter": "^2.0.1", + "karma-mocha-reporter": "^2.2.5", + "karma-mocha": "^2.0.1", + "karma-source-map-support": "~1.4.0", + "karma-sourcemap-loader": "^0.4.0", + "karma": "^6.2.0", + "c8": "^8.0.0", + "ts-node": "^10.0.0" + }, + "homepage": "https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/purview/purview-datamap-rest/README.md", + "//metadata": { + "constantPaths": [ + { + "path": "src/purviewDataMapClient.ts", + "prefix": "userAgentInfo" + } + ] + }, + "browser": { + "./dist-esm/test/public/utils/env.js": "./dist-esm/test/public/utils/env.browser.js" + } +} \ No newline at end of file diff --git a/sdk/purview/purview-datamap-rest/review/purview-datamap.api.md b/sdk/purview/purview-datamap-rest/review/purview-datamap.api.md new file mode 100644 index 000000000000..340eab6a542b --- /dev/null +++ b/sdk/purview/purview-datamap-rest/review/purview-datamap.api.md @@ -0,0 +1,4709 @@ +## API Report File for "@azure-rest/purview-datamap" + +> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/). + +```ts + +import { Client } from '@azure-rest/core-client'; +import { ClientOptions } from '@azure-rest/core-client'; +import { HttpResponse } from '@azure-rest/core-client'; +import { RequestParameters } from '@azure-rest/core-client'; +import { StreamableMethod } from '@azure-rest/core-client'; +import { TokenCredential } from '@azure/core-auth'; + +// @public +export interface AndFilter extends SearchFilterParent { + and: Array; + kind: "AndFilter"; +} + +// @public +export interface AssetTypeFilter extends SearchFilterParent { + assetType: string; + kind: "AssetTypeFilter"; +} + +// @public +export interface AtlasAttributeDef { + cardinality?: string; + constraints?: Array; + defaultValue?: string; + description?: string; + includeInNotification?: boolean; + isIndexable?: boolean; + isOptional?: boolean; + isUnique?: boolean; + name?: string; + options?: Record; + typeName?: string; + valuesMaxCount?: number; + valuesMinCount?: number; +} + +// @public +export interface AtlasAttributeDefOutput { + cardinality?: string; + constraints?: Array; + defaultValue?: string; + description?: string; + includeInNotification?: boolean; + isIndexable?: boolean; + isOptional?: boolean; + isUnique?: boolean; + name?: string; + options?: Record; + typeName?: string; + valuesMaxCount?: number; + valuesMinCount?: number; +} + +// @public +export interface AtlasBusinessMetadataDef { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormat; + description?: string; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasBusinessMetadataDefOutput { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormatOutput; + description?: string; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasClassification { + attributes?: Record; + entityGuid?: string; + entityStatus?: string; + lastModifiedTS?: string; + removePropagationsOnEntityDelete?: boolean; + typeName?: string; + validityPeriods?: Array; +} + +// @public +export interface AtlasClassificationDef { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormat; + description?: string; + entityTypes?: string[]; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + subTypes?: string[]; + superTypes?: string[]; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasClassificationDefOutput { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormatOutput; + description?: string; + entityTypes?: string[]; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + subTypes?: string[]; + superTypes?: string[]; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasClassificationOutput { + attributes?: Record; + entityGuid?: string; + entityStatus?: string; + lastModifiedTS?: string; + removePropagationsOnEntityDelete?: boolean; + typeName?: string; + validityPeriods?: Array; +} + +// @public +export interface AtlasClassificationsOutput { + list?: any[]; + pageSize?: number; + sortBy?: string; + sortType?: string; + startIndex?: number; + totalCount?: number; +} + +// @public +export interface AtlasConstraintDef { + params?: Record; + type?: string; +} + +// @public +export interface AtlasConstraintDefOutput { + params?: Record; + type?: string; +} + +// @public +export interface AtlasEntitiesWithExtInfo { + entities?: Array; + referredEntities?: Record; +} + +// @public +export interface AtlasEntitiesWithExtInfoOutput { + entities?: Array; + referredEntities?: Record; +} + +// @public +export interface AtlasEntity { + attributes?: Record; + businessAttributes?: Record; + classifications?: Array; + contacts?: Record>; + createdBy?: string; + createTime?: number; + customAttributes?: Record; + guid?: string; + homeId?: string; + isIncomplete?: boolean; + labels?: string[]; + lastModifiedTS?: string; + meanings?: Array; + provenanceType?: number; + proxy?: boolean; + relationshipAttributes?: Record; + status?: string; + typeName?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasEntityDef { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormat; + description?: string; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + relationshipAttributeDefs?: Array; + serviceType?: string; + subTypes?: string[]; + superTypes?: string[]; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasEntityDefOutput { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormatOutput; + description?: string; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + relationshipAttributeDefs?: Array; + serviceType?: string; + subTypes?: string[]; + superTypes?: string[]; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasEntityHeader { + attributes?: Record; + classificationNames?: string[]; + classifications?: Array; + displayText?: string; + guid?: string; + isIncomplete?: boolean; + labels?: string[]; + lastModifiedTS?: string; + meaningNames?: string[]; + meanings?: Array; + status?: string; + typeName?: string; +} + +// @public +export interface AtlasEntityHeaderOutput { + attributes?: Record; + classificationNames?: string[]; + classifications?: Array; + displayText?: string; + guid?: string; + isIncomplete?: boolean; + labels?: string[]; + lastModifiedTS?: string; + meaningNames?: string[]; + meanings?: Array; + status?: string; + typeName?: string; +} + +// @public +export interface AtlasEntityHeaders { + guidHeaderMap?: Record; +} + +// @public +export interface AtlasEntityOutput { + attributes?: Record; + businessAttributes?: Record; + classifications?: Array; + readonly collectionId?: string; + contacts?: Record>; + createdBy?: string; + createTime?: number; + customAttributes?: Record; + guid?: string; + homeId?: string; + isIncomplete?: boolean; + labels?: string[]; + lastModifiedTS?: string; + meanings?: Array; + provenanceType?: number; + proxy?: boolean; + relationshipAttributes?: Record; + status?: string; + typeName?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasEntityWithExtInfo { + entity?: AtlasEntity; + referredEntities?: Record; +} + +// @public +export interface AtlasEntityWithExtInfoOutput { + entity?: AtlasEntityOutput; + referredEntities?: Record; +} + +// @public +export interface AtlasEnumDef { + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormat; + defaultValue?: string; + description?: string; + elementDefs?: Array; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasEnumDefOutput { + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormatOutput; + defaultValue?: string; + description?: string; + elementDefs?: Array; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasEnumElementDef { + description?: string; + ordinal?: number; + value?: string; +} + +// @public +export interface AtlasEnumElementDefOutput { + description?: string; + ordinal?: number; + value?: string; +} + +// @public +export interface AtlasErrorResponseOutput { + errorCode?: string; + errorMessage?: string; + requestId?: string; +} + +// @public +export interface AtlasGlossary { + categories?: Array; + classifications?: Array; + createdBy?: string; + createTime?: number; + guid?: string; + language?: string; + lastModifiedTS?: string; + longDescription?: string; + name?: string; + qualifiedName?: string; + shortDescription?: string; + terms?: Array; + updatedBy?: string; + updateTime?: number; + usage?: string; +} + +// @public +export interface AtlasGlossaryCategory { + anchor?: AtlasGlossaryHeader; + childrenCategories?: Array; + classifications?: Array; + createdBy?: string; + createTime?: number; + guid?: string; + lastModifiedTS?: string; + longDescription?: string; + name?: string; + parentCategory?: AtlasRelatedCategoryHeader; + qualifiedName?: string; + shortDescription?: string; + terms?: Array; + updatedBy?: string; + updateTime?: number; +} + +// @public +export interface AtlasGlossaryCategoryOutput { + anchor?: AtlasGlossaryHeaderOutput; + childrenCategories?: Array; + classifications?: Array; + createdBy?: string; + createTime?: number; + guid?: string; + lastModifiedTS?: string; + longDescription?: string; + name?: string; + parentCategory?: AtlasRelatedCategoryHeaderOutput; + qualifiedName?: string; + shortDescription?: string; + terms?: Array; + updatedBy?: string; + updateTime?: number; +} + +// @public +export interface AtlasGlossaryExtInfoOutput { + categories?: Array; + categoryInfo?: Record; + classifications?: Array; + createdBy?: string; + createTime?: number; + guid?: string; + language?: string; + lastModifiedTS?: string; + longDescription?: string; + name?: string; + qualifiedName?: string; + shortDescription?: string; + termInfo?: Record; + terms?: Array; + updatedBy?: string; + updateTime?: number; + usage?: string; +} + +// @public +export interface AtlasGlossaryHeader { + displayText?: string; + glossaryGuid?: string; + relationGuid?: string; +} + +// @public +export interface AtlasGlossaryHeaderOutput { + displayText?: string; + glossaryGuid?: string; + relationGuid?: string; +} + +// @public +export interface AtlasGlossaryOutput { + categories?: Array; + classifications?: Array; + createdBy?: string; + createTime?: number; + guid?: string; + language?: string; + lastModifiedTS?: string; + longDescription?: string; + name?: string; + qualifiedName?: string; + shortDescription?: string; + terms?: Array; + updatedBy?: string; + updateTime?: number; + usage?: string; +} + +// @public +export interface AtlasGlossaryTerm { + abbreviation?: string; + anchor?: AtlasGlossaryHeader; + antonyms?: Array; + assignedEntities?: Array; + attributes?: Record>; + categories?: Array; + classifications?: Array; + classifies?: Array; + contacts?: Record>; + createdBy?: string; + createTime?: number; + examples?: string[]; + guid?: string; + hierarchyInfo?: Array; + isA?: Array; + lastModifiedTS?: string; + longDescription?: string; + name?: string; + nickName?: string; + preferredTerms?: Array; + preferredToTerms?: Array; + qualifiedName?: string; + replacedBy?: Array; + replacementTerms?: Array; + resources?: Array; + seeAlso?: Array; + shortDescription?: string; + status?: string; + synonyms?: Array; + templateName?: unknown[]; + translatedTerms?: Array; + translationTerms?: Array; + updatedBy?: string; + updateTime?: number; + usage?: string; + validValues?: Array; + validValuesFor?: Array; +} + +// @public +export interface AtlasGlossaryTermOutput { + abbreviation?: string; + anchor?: AtlasGlossaryHeaderOutput; + antonyms?: Array; + assignedEntities?: Array; + attributes?: Record>; + categories?: Array; + classifications?: Array; + classifies?: Array; + contacts?: Record>; + createdBy?: string; + createTime?: number; + examples?: string[]; + guid?: string; + hierarchyInfo?: Array; + isA?: Array; + lastModifiedTS?: string; + longDescription?: string; + name?: string; + nickName?: string; + preferredTerms?: Array; + preferredToTerms?: Array; + qualifiedName?: string; + replacedBy?: Array; + replacementTerms?: Array; + resources?: Array; + seeAlso?: Array; + shortDescription?: string; + status?: string; + synonyms?: Array; + templateName?: any[]; + translatedTerms?: Array; + translationTerms?: Array; + updatedBy?: string; + updateTime?: number; + usage?: string; + validValues?: Array; + validValuesFor?: Array; +} + +// @public +export interface AtlasLineageInfoOutput { + baseEntityGuid?: string; + childrenCount?: number; + guidEntityMap?: Record; + lineageDepth?: number; + lineageDirection?: string; + lineageWidth?: number; + parentRelations?: Array; + relations?: Array; + widthCounts?: Record>; +} + +// @public +export interface AtlasObjectId { + guid?: string; + typeName?: string; + uniqueAttributes?: Record; +} + +// @public +export interface AtlasObjectIdOutput { + guid?: string; + typeName?: string; + uniqueAttributes?: Record; +} + +// @public +export interface AtlasRelatedCategoryHeader { + categoryGuid?: string; + description?: string; + displayText?: string; + parentCategoryGuid?: string; + relationGuid?: string; +} + +// @public +export interface AtlasRelatedCategoryHeaderOutput { + categoryGuid?: string; + description?: string; + displayText?: string; + parentCategoryGuid?: string; + relationGuid?: string; +} + +// @public +export interface AtlasRelatedObjectId { + displayText?: string; + entityStatus?: string; + guid?: string; + relationshipAttributes?: AtlasStruct; + relationshipGuid?: string; + relationshipStatus?: string; + relationshipType?: string; + typeName?: string; + uniqueAttributes?: Record; +} + +// @public +export interface AtlasRelatedObjectIdOutput { + displayText?: string; + entityStatus?: string; + guid?: string; + relationshipAttributes?: AtlasStructOutput; + relationshipGuid?: string; + relationshipStatus?: string; + relationshipType?: string; + typeName?: string; + uniqueAttributes?: Record; +} + +// @public +export interface AtlasRelatedTermHeader { + description?: string; + displayText?: string; + expression?: string; + relationGuid?: string; + status?: string; + steward?: string; + termGuid?: string; +} + +// @public +export interface AtlasRelatedTermHeaderOutput { + description?: string; + displayText?: string; + expression?: string; + relationGuid?: string; + status?: string; + steward?: string; + termGuid?: string; +} + +// @public +export interface AtlasRelationship { + attributes?: Record; + createdBy?: string; + createTime?: number; + end1?: AtlasObjectId; + end2?: AtlasObjectId; + guid?: string; + homeId?: string; + label?: string; + lastModifiedTS?: string; + provenanceType?: number; + status?: string; + typeName?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasRelationshipAttributeDef { + cardinality?: string; + constraints?: Array; + defaultValue?: string; + description?: string; + includeInNotification?: boolean; + isIndexable?: boolean; + isLegacyAttribute?: boolean; + isOptional?: boolean; + isUnique?: boolean; + name?: string; + options?: Record; + relationshipTypeName?: string; + typeName?: string; + valuesMaxCount?: number; + valuesMinCount?: number; +} + +// @public +export interface AtlasRelationshipAttributeDefOutput { + cardinality?: string; + constraints?: Array; + defaultValue?: string; + description?: string; + includeInNotification?: boolean; + isIndexable?: boolean; + isLegacyAttribute?: boolean; + isOptional?: boolean; + isUnique?: boolean; + name?: string; + options?: Record; + relationshipTypeName?: string; + typeName?: string; + valuesMaxCount?: number; + valuesMinCount?: number; +} + +// @public +export interface AtlasRelationshipDef { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormat; + description?: string; + endDef1?: AtlasRelationshipEndDef; + endDef2?: AtlasRelationshipEndDef; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + relationshipCategory?: string; + relationshipLabel?: string; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasRelationshipDefOutput { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormatOutput; + description?: string; + endDef1?: AtlasRelationshipEndDefOutput; + endDef2?: AtlasRelationshipEndDefOutput; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + relationshipCategory?: string; + relationshipLabel?: string; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasRelationshipEndDef { + cardinality?: string; + description?: string; + isContainer?: boolean; + isLegacyAttribute?: boolean; + name?: string; + type?: string; +} + +// @public +export interface AtlasRelationshipEndDefOutput { + cardinality?: string; + description?: string; + isContainer?: boolean; + isLegacyAttribute?: boolean; + name?: string; + type?: string; +} + +// @public +export interface AtlasRelationshipOutput { + attributes?: Record; + createdBy?: string; + createTime?: number; + end1?: AtlasObjectIdOutput; + end2?: AtlasObjectIdOutput; + guid?: string; + homeId?: string; + label?: string; + lastModifiedTS?: string; + provenanceType?: number; + status?: string; + typeName?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasRelationshipWithExtInfoOutput { + referredEntities?: Record; + relationship?: AtlasRelationshipOutput; +} + +// @public +export interface AtlasStruct { + attributes?: Record; + lastModifiedTS?: string; + typeName?: string; +} + +// @public +export interface AtlasStructDef { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormat; + description?: string; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasStructDefOutput { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormatOutput; + description?: string; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasStructOutput { + attributes?: Record; + lastModifiedTS?: string; + typeName?: string; +} + +// @public +export interface AtlasTermAssignmentHeader { + confidence?: number; + createdBy?: string; + description?: string; + displayText?: string; + expression?: string; + relationGuid?: string; + status?: string; + steward?: string; + termGuid?: string; +} + +// @public +export interface AtlasTermAssignmentHeaderOutput { + confidence?: number; + createdBy?: string; + description?: string; + displayText?: string; + expression?: string; + relationGuid?: string; + status?: string; + steward?: string; + termGuid?: string; +} + +// @public +export interface AtlasTermCategorizationHeader { + categoryGuid?: string; + description?: string; + displayText?: string; + relationGuid?: string; + status?: string; +} + +// @public +export interface AtlasTermCategorizationHeaderOutput { + categoryGuid?: string; + description?: string; + displayText?: string; + relationGuid?: string; + status?: string; +} + +// @public +export interface AtlasTypeDefHeaderOutput { + category?: string; + guid?: string; + name?: string; +} + +// @public +export interface AtlasTypeDefOutput { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormatOutput; + defaultValue?: string; + description?: string; + elementDefs?: Array; + endDef1?: AtlasRelationshipEndDefOutput; + endDef2?: AtlasRelationshipEndDefOutput; + entityTypes?: string[]; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + relationshipAttributeDefs?: Array; + relationshipCategory?: string; + relationshipLabel?: string; + serviceType?: string; + subTypes?: string[]; + superTypes?: string[]; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface AtlasTypesDef { + businessMetadataDefs?: Array; + classificationDefs?: Array; + entityDefs?: Array; + enumDefs?: Array; + relationshipDefs?: Array; + structDefs?: Array; + termTemplateDefs?: Array; +} + +// @public +export interface AtlasTypesDefOutput { + businessMetadataDefs?: Array; + classificationDefs?: Array; + entityDefs?: Array; + enumDefs?: Array; + relationshipDefs?: Array; + structDefs?: Array; + termTemplateDefs?: Array; +} + +// @public +export interface AttributeFilter extends SearchFilterParent { + attributeName: string; + attributeValue: unknown; + kind: "AttributeFilter"; + operator: string; +} + +// @public +export interface AutoCompleteContent { + filter?: SearchFilter; + keywords?: string; + limit?: number; +} + +// @public +export interface AutoCompleteResultOutput { + value?: Array; +} + +// @public +export interface AutoCompleteResultValueOutput { + queryPlusText?: string; + text?: string; +} + +// @public (undocumented) +export function buildMultiCollection(items: string[], parameterName: string): string; + +// @public +export interface BulkImportResultOutput { + failedImportInfoList?: Array; + successImportInfoList?: Array; +} + +// @public +export interface ClassificationAssociateContent { + classification?: AtlasClassification; + entityGuids?: string[]; +} + +// @public +export interface ClassificationCategoryFilter extends SearchFilterParent { + classificationCategory: string; + kind: "ClassificationCategoryFilter"; +} + +// @public +export interface ClassificationFilter extends SearchFilterParent { + classification: string; + includeSubClassifications?: boolean; + kind: "ClassificationFilter"; +} + +// @public +export interface CollectionIdFilter extends SearchFilterParent { + collectionId: string; + kind: "CollectionIdFilter"; +} + +// @public +export interface ContactBasic { + id?: string; + info?: string; +} + +// @public +export interface ContactBasicOutput { + id?: string; + info?: string; +} + +// @public +export interface ContactFilter extends SearchFilterParent { + contactId?: string; + contactType?: string; + kind: "ContactFilter"; +} + +// @public +export interface ContactSearchResultValueOutput { + contactType?: string; + id?: string; + info?: string; +} + +// @public +function createClient(endpoint: string, credentials: TokenCredential, options?: ClientOptions): PurviewDataMapClient; +export default createClient; + +// @public +export interface CreateTimeFilter extends SearchFilterParent { + createTime: unknown; + kind: "CreateTimeFilter"; +} + +// @public +export interface DateFormat { + availableLocales?: string[]; + calendar?: number; + dateInstance?: DateFormat; + dateTimeInstance?: DateFormat; + instance?: DateFormat; + lenient?: boolean; + numberFormat?: NumberFormat; + timeInstance?: DateFormat; + timeZone?: TimeZone; +} + +// @public +export interface DateFormatOutput { + availableLocales?: string[]; + calendar?: number; + dateInstance?: DateFormatOutput; + dateTimeInstance?: DateFormatOutput; + instance?: DateFormatOutput; + lenient?: boolean; + numberFormat?: NumberFormatOutput; + timeInstance?: DateFormatOutput; + timeZone?: TimeZoneOutput; +} + +// @public (undocumented) +export interface DiscoveryAutoComplete { + post(options: DiscoveryAutoCompleteParameters): StreamableMethod; +} + +// @public +export interface DiscoveryAutoComplete200Response extends HttpResponse { + // (undocumented) + body: AutoCompleteResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface DiscoveryAutoCompleteBodyParam { + body: AutoCompleteContent; +} + +// @public (undocumented) +export interface DiscoveryAutoCompleteDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type DiscoveryAutoCompleteParameters = DiscoveryAutoCompleteBodyParam & RequestParameters; + +// @public (undocumented) +export interface DiscoveryQuery { + post(options: DiscoveryQueryParameters): StreamableMethod; +} + +// @public +export interface DiscoveryQuery200Response extends HttpResponse { + // (undocumented) + body: SearchResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface DiscoveryQueryBodyParam { + body: SearchContent; +} + +// @public (undocumented) +export interface DiscoveryQueryDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type DiscoveryQueryParameters = DiscoveryQueryBodyParam & RequestParameters; + +// @public (undocumented) +export interface DiscoverySuggest { + post(options: DiscoverySuggestParameters): StreamableMethod; +} + +// @public +export interface DiscoverySuggest200Response extends HttpResponse { + // (undocumented) + body: SuggestResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface DiscoverySuggestBodyParam { + body: SuggestContent; +} + +// @public (undocumented) +export interface DiscoverySuggestDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type DiscoverySuggestParameters = DiscoverySuggestBodyParam & RequestParameters; + +// @public +export interface DomainIdFilter extends SearchFilterParent { + domainId: string; + kind: "DomainIdFilter"; +} + +// @public (undocumented) +export interface EntityAddClassification { + post(options: EntityAddClassificationParameters): StreamableMethod; +} + +// @public +export interface EntityAddClassification204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityAddClassificationBodyParam { + body: ClassificationAssociateContent; +} + +// @public (undocumented) +export interface EntityAddClassificationDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityAddClassificationParameters = EntityAddClassificationBodyParam & RequestParameters; + +// @public +export interface EntityAddClassifications204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityAddClassificationsBodyParam { + body: Array; +} + +// @public (undocumented) +export interface EntityAddClassificationsByUniqueAttribute { + post(options: EntityAddClassificationsByUniqueAttributeParameters): StreamableMethod; + put(options: EntityUpdateClassificationsByUniqueAttributeParameters): StreamableMethod; +} + +// @public +export interface EntityAddClassificationsByUniqueAttribute204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityAddClassificationsByUniqueAttributeBodyParam { + body: Array; +} + +// @public (undocumented) +export interface EntityAddClassificationsByUniqueAttributeDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityAddClassificationsByUniqueAttributeParameters = EntityAddClassificationsByUniqueAttributeQueryParam & EntityAddClassificationsByUniqueAttributeBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityAddClassificationsByUniqueAttributeQueryParam { + // (undocumented) + queryParameters?: EntityAddClassificationsByUniqueAttributeQueryParamProperties; +} + +// @public (undocumented) +export interface EntityAddClassificationsByUniqueAttributeQueryParamProperties { + "attr:qualifiedName"?: string; +} + +// @public (undocumented) +export interface EntityAddClassificationsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityAddClassificationsParameters = EntityAddClassificationsBodyParam & RequestParameters; + +// @public +export interface EntityAddLabel204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityAddLabelBodyParam { + body: string[]; +} + +// @public (undocumented) +export interface EntityAddLabelDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityAddLabelParameters = EntityAddLabelBodyParam & RequestParameters; + +// @public +export interface EntityAddLabelsByUniqueAttribute204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityAddLabelsByUniqueAttributeBodyParam { + body: string[]; +} + +// @public (undocumented) +export interface EntityAddLabelsByUniqueAttributeDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityAddLabelsByUniqueAttributeParameters = EntityAddLabelsByUniqueAttributeQueryParam & EntityAddLabelsByUniqueAttributeBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityAddLabelsByUniqueAttributeQueryParam { + // (undocumented) + queryParameters?: EntityAddLabelsByUniqueAttributeQueryParamProperties; +} + +// @public (undocumented) +export interface EntityAddLabelsByUniqueAttributeQueryParamProperties { + "attr:qualifiedName"?: string; +} + +// @public +export interface EntityAddOrUpdateBusinessMetadata204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public +export interface EntityAddOrUpdateBusinessMetadataAttributes204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityAddOrUpdateBusinessMetadataAttributesBodyParam { + body: Record; +} + +// @public (undocumented) +export interface EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityAddOrUpdateBusinessMetadataAttributesParameters = EntityAddOrUpdateBusinessMetadataAttributesBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityAddOrUpdateBusinessMetadataBodyParam { + body: Record>; +} + +// @public (undocumented) +export interface EntityAddOrUpdateBusinessMetadataDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityAddOrUpdateBusinessMetadataParameters = EntityAddOrUpdateBusinessMetadataQueryParam & EntityAddOrUpdateBusinessMetadataBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityAddOrUpdateBusinessMetadataQueryParam { + // (undocumented) + queryParameters?: EntityAddOrUpdateBusinessMetadataQueryParamProperties; +} + +// @public (undocumented) +export interface EntityAddOrUpdateBusinessMetadataQueryParamProperties { + isOverwrite?: boolean; +} + +// @public +export interface EntityBulkCreateOrUpdate200Response extends HttpResponse { + // (undocumented) + body: EntityMutationResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityBulkCreateOrUpdateBodyParam { + body: AtlasEntitiesWithExtInfo; +} + +// @public (undocumented) +export interface EntityBulkCreateOrUpdateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityBulkCreateOrUpdateParameters = EntityBulkCreateOrUpdateQueryParam & EntityBulkCreateOrUpdateBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityBulkCreateOrUpdateQueryParam { + // (undocumented) + queryParameters?: EntityBulkCreateOrUpdateQueryParamProperties; +} + +// @public (undocumented) +export interface EntityBulkCreateOrUpdateQueryParamProperties { + businessAttributeUpdateBehavior?: string; + collectionId?: string; +} + +// @public +export interface EntityBulkDelete200Response extends HttpResponse { + // (undocumented) + body: EntityMutationResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityBulkDeleteDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityBulkDeleteParameters = EntityBulkDeleteQueryParam & RequestParameters; + +// @public (undocumented) +export interface EntityBulkDeleteQueryParam { + // (undocumented) + queryParameters: EntityBulkDeleteQueryParamProperties; +} + +// @public (undocumented) +export interface EntityBulkDeleteQueryParamProperties { + guid: string; +} + +// @public (undocumented) +export interface EntityBulkSetClassifications { + post(options: EntityBulkSetClassificationsParameters): StreamableMethod; +} + +// @public +export interface EntityBulkSetClassifications200Response extends HttpResponse { + // (undocumented) + body: string[]; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityBulkSetClassificationsBodyParam { + body: AtlasEntityHeaders; +} + +// @public (undocumented) +export interface EntityBulkSetClassificationsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityBulkSetClassificationsParameters = EntityBulkSetClassificationsBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityCreateOrUpdate { + post(options: EntityCreateOrUpdateParameters): StreamableMethod; +} + +// @public +export interface EntityCreateOrUpdate200Response extends HttpResponse { + // (undocumented) + body: EntityMutationResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityCreateOrUpdateBodyParam { + body: AtlasEntityWithExtInfo; +} + +// @public (undocumented) +export interface EntityCreateOrUpdateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityCreateOrUpdateParameters = EntityCreateOrUpdateQueryParam & EntityCreateOrUpdateBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityCreateOrUpdateQueryParam { + // (undocumented) + queryParameters?: EntityCreateOrUpdateQueryParamProperties; +} + +// @public (undocumented) +export interface EntityCreateOrUpdateQueryParamProperties { + businessAttributeUpdateBehavior?: string; + collectionId?: string; +} + +// @public +export interface EntityDeleteByUniqueAttribute200Response extends HttpResponse { + // (undocumented) + body: EntityMutationResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityDeleteByUniqueAttributeDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityDeleteByUniqueAttributeParameters = EntityDeleteByUniqueAttributeQueryParam & RequestParameters; + +// @public (undocumented) +export interface EntityDeleteByUniqueAttributeQueryParam { + // (undocumented) + queryParameters?: EntityDeleteByUniqueAttributeQueryParamProperties; +} + +// @public (undocumented) +export interface EntityDeleteByUniqueAttributeQueryParamProperties { + "attr:qualifiedName"?: string; +} + +// @public +export interface EntityDeleteOperation200Response extends HttpResponse { + // (undocumented) + body: EntityMutationResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityDeleteOperationDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityDeleteParameters = RequestParameters; + +// @public (undocumented) +export interface EntityGet { + delete(options?: EntityDeleteParameters): StreamableMethod; + get(options?: EntityGetParameters): StreamableMethod; + put(options: EntityPartialUpdateAttributeByGuidParameters): StreamableMethod; +} + +// @public +export interface EntityGet200Response extends HttpResponse { + // (undocumented) + body: AtlasEntityWithExtInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityGetByUniqueAttributes { + delete(options?: EntityDeleteByUniqueAttributeParameters): StreamableMethod; + get(options?: EntityGetByUniqueAttributesParameters): StreamableMethod; + put(options: EntityPartialUpdateByUniqueAttributesParameters): StreamableMethod; +} + +// @public +export interface EntityGetByUniqueAttributes200Response extends HttpResponse { + // (undocumented) + body: AtlasEntityWithExtInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityGetByUniqueAttributesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityGetByUniqueAttributesParameters = EntityGetByUniqueAttributesQueryParam & RequestParameters; + +// @public (undocumented) +export interface EntityGetByUniqueAttributesQueryParam { + // (undocumented) + queryParameters?: EntityGetByUniqueAttributesQueryParamProperties; +} + +// @public (undocumented) +export interface EntityGetByUniqueAttributesQueryParamProperties { + "attr:qualifiedName"?: string; + ignoreRelationships?: boolean; + minExtInfo?: boolean; +} + +// @public (undocumented) +export interface EntityGetClassification { + delete(options?: EntityRemoveClassificationParameters): StreamableMethod; + get(options?: EntityGetClassificationParameters): StreamableMethod; +} + +// @public +export interface EntityGetClassification200Response extends HttpResponse { + // (undocumented) + body: AtlasClassificationOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityGetClassificationDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityGetClassificationParameters = RequestParameters; + +// @public (undocumented) +export interface EntityGetClassifications { + get(options?: EntityGetClassificationsParameters): StreamableMethod; + post(options: EntityAddClassificationsParameters): StreamableMethod; + put(options: EntityUpdateClassificationsParameters): StreamableMethod; +} + +// @public +export interface EntityGetClassifications200Response extends HttpResponse { + // (undocumented) + body: AtlasClassificationsOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityGetClassificationsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityGetClassificationsParameters = RequestParameters; + +// @public (undocumented) +export interface EntityGetDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export interface EntityGetHeader { + get(options?: EntityGetHeaderParameters): StreamableMethod; +} + +// @public +export interface EntityGetHeader200Response extends HttpResponse { + // (undocumented) + body: AtlasEntityHeaderOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityGetHeaderDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityGetHeaderParameters = RequestParameters; + +// @public (undocumented) +export type EntityGetParameters = EntityGetQueryParam & RequestParameters; + +// @public (undocumented) +export interface EntityGetQueryParam { + // (undocumented) + queryParameters?: EntityGetQueryParamProperties; +} + +// @public (undocumented) +export interface EntityGetQueryParamProperties { + ignoreRelationships?: boolean; + minExtInfo?: boolean; +} + +// @public (undocumented) +export interface EntityGetSampleBusinessMetadataTemplate { + get(options?: EntityGetSampleBusinessMetadataTemplateParameters): StreamableMethod; +} + +// @public +export interface EntityGetSampleBusinessMetadataTemplate200Response extends HttpResponse { + body: Uint8Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityGetSampleBusinessMetadataTemplateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityGetSampleBusinessMetadataTemplateParameters = RequestParameters; + +// @public (undocumented) +export interface EntityImportBusinessMetadata { + post(options: EntityImportBusinessMetadataParameters): StreamableMethod; +} + +// @public +export interface EntityImportBusinessMetadata200Response extends HttpResponse { + // (undocumented) + body: BulkImportResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityImportBusinessMetadataBodyParam { + // (undocumented) + body?: { + uploadedInputStream: string; + }; +} + +// @public (undocumented) +export interface EntityImportBusinessMetadataDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export interface EntityImportBusinessMetadataMediaTypesParam { + contentType: "multipart/form-data"; +} + +// @public (undocumented) +export type EntityImportBusinessMetadataParameters = EntityImportBusinessMetadataMediaTypesParam & EntityImportBusinessMetadataBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityListByGuids { + delete(options: EntityBulkDeleteParameters): StreamableMethod; + get(options: EntityListByGuidsParameters): StreamableMethod; + post(options: EntityBulkCreateOrUpdateParameters): StreamableMethod; +} + +// @public +export interface EntityListByGuids200Response extends HttpResponse { + // (undocumented) + body: AtlasEntitiesWithExtInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityListByGuidsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityListByGuidsParameters = EntityListByGuidsQueryParam & RequestParameters; + +// @public (undocumented) +export interface EntityListByGuidsQueryParam { + // (undocumented) + queryParameters: EntityListByGuidsQueryParamProperties; +} + +// @public (undocumented) +export interface EntityListByGuidsQueryParamProperties { + guid: string; + ignoreRelationships?: boolean; + minExtInfo?: boolean; +} + +// @public (undocumented) +export interface EntityListByUniqueAttributes { + get(options?: EntityListByUniqueAttributesParameters): StreamableMethod; +} + +// @public +export interface EntityListByUniqueAttributes200Response extends HttpResponse { + // (undocumented) + body: AtlasEntitiesWithExtInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityListByUniqueAttributesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityListByUniqueAttributesParameters = EntityListByUniqueAttributesQueryParam & RequestParameters; + +// @public (undocumented) +export interface EntityListByUniqueAttributesQueryParam { + // (undocumented) + queryParameters?: EntityListByUniqueAttributesQueryParamProperties; +} + +// @public (undocumented) +export interface EntityListByUniqueAttributesQueryParamProperties { + "attr_N:qualifiedName"?: string; + ignoreRelationships?: boolean; + minExtInfo?: boolean; +} + +// @public (undocumented) +export interface EntityMoveEntitiesToCollection { + post(options: EntityMoveEntitiesToCollectionParameters): StreamableMethod; +} + +// @public +export interface EntityMoveEntitiesToCollection200Response extends HttpResponse { + // (undocumented) + body: EntityMutationResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityMoveEntitiesToCollectionBodyParam { + body: MoveEntitiesContent; +} + +// @public (undocumented) +export interface EntityMoveEntitiesToCollectionDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityMoveEntitiesToCollectionParameters = EntityMoveEntitiesToCollectionQueryParam & EntityMoveEntitiesToCollectionBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityMoveEntitiesToCollectionQueryParam { + // (undocumented) + queryParameters: EntityMoveEntitiesToCollectionQueryParamProperties; +} + +// @public (undocumented) +export interface EntityMoveEntitiesToCollectionQueryParamProperties { + collectionId: string; +} + +// @public +export interface EntityMutationResultOutput { + guidAssignments?: Record; + mutatedEntities?: Record>; + partialUpdatedEntities?: Array; +} + +// @public +export interface EntityPartialUpdateAttributeByGuid200Response extends HttpResponse { + // (undocumented) + body: EntityMutationResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityPartialUpdateAttributeByGuidBodyParam { + body: unknown; +} + +// @public (undocumented) +export interface EntityPartialUpdateAttributeByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityPartialUpdateAttributeByGuidParameters = EntityPartialUpdateAttributeByGuidQueryParam & EntityPartialUpdateAttributeByGuidBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityPartialUpdateAttributeByGuidQueryParam { + // (undocumented) + queryParameters: EntityPartialUpdateAttributeByGuidQueryParamProperties; +} + +// @public (undocumented) +export interface EntityPartialUpdateAttributeByGuidQueryParamProperties { + name: string; +} + +// @public +export interface EntityPartialUpdateByUniqueAttributes200Response extends HttpResponse { + // (undocumented) + body: EntityMutationResultOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface EntityPartialUpdateByUniqueAttributesBodyParam { + body: AtlasEntityWithExtInfo; +} + +// @public (undocumented) +export interface EntityPartialUpdateByUniqueAttributesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityPartialUpdateByUniqueAttributesParameters = EntityPartialUpdateByUniqueAttributesQueryParam & EntityPartialUpdateByUniqueAttributesBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityPartialUpdateByUniqueAttributesQueryParam { + // (undocumented) + queryParameters?: EntityPartialUpdateByUniqueAttributesQueryParamProperties; +} + +// @public (undocumented) +export interface EntityPartialUpdateByUniqueAttributesQueryParamProperties { + "attr:qualifiedName"?: string; +} + +// @public (undocumented) +export interface EntityRemoveBusinessMetadata { + delete(options: EntityRemoveBusinessMetadataParameters): StreamableMethod; + post(options: EntityAddOrUpdateBusinessMetadataParameters): StreamableMethod; +} + +// @public +export interface EntityRemoveBusinessMetadata204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityRemoveBusinessMetadataAttributes { + delete(options: EntityRemoveBusinessMetadataAttributesParameters): StreamableMethod; + post(options: EntityAddOrUpdateBusinessMetadataAttributesParameters): StreamableMethod; +} + +// @public +export interface EntityRemoveBusinessMetadataAttributes204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityRemoveBusinessMetadataAttributesBodyParam { + body: Record; +} + +// @public (undocumented) +export interface EntityRemoveBusinessMetadataAttributesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityRemoveBusinessMetadataAttributesParameters = EntityRemoveBusinessMetadataAttributesBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityRemoveBusinessMetadataBodyParam { + body: Record>; +} + +// @public (undocumented) +export interface EntityRemoveBusinessMetadataDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityRemoveBusinessMetadataParameters = EntityRemoveBusinessMetadataBodyParam & RequestParameters; + +// @public +export interface EntityRemoveClassification204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityRemoveClassificationByUniqueAttribute { + delete(options?: EntityRemoveClassificationByUniqueAttributeParameters): StreamableMethod; +} + +// @public +export interface EntityRemoveClassificationByUniqueAttribute204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityRemoveClassificationByUniqueAttributeDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityRemoveClassificationByUniqueAttributeParameters = EntityRemoveClassificationByUniqueAttributeQueryParam & RequestParameters; + +// @public (undocumented) +export interface EntityRemoveClassificationByUniqueAttributeQueryParam { + // (undocumented) + queryParameters?: EntityRemoveClassificationByUniqueAttributeQueryParamProperties; +} + +// @public (undocumented) +export interface EntityRemoveClassificationByUniqueAttributeQueryParamProperties { + "attr:qualifiedName"?: string; +} + +// @public (undocumented) +export interface EntityRemoveClassificationDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityRemoveClassificationParameters = RequestParameters; + +// @public (undocumented) +export interface EntityRemoveLabels { + delete(options: EntityRemoveLabelsParameters): StreamableMethod; + post(options: EntitySetLabelsParameters): StreamableMethod; + put(options: EntityAddLabelParameters): StreamableMethod; +} + +// @public +export interface EntityRemoveLabels204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityRemoveLabelsBodyParam { + body: string[]; +} + +// @public (undocumented) +export interface EntityRemoveLabelsByUniqueAttribute { + delete(options: EntityRemoveLabelsByUniqueAttributeParameters): StreamableMethod; + post(options: EntitySetLabelsByUniqueAttributeParameters): StreamableMethod; + put(options: EntityAddLabelsByUniqueAttributeParameters): StreamableMethod; +} + +// @public +export interface EntityRemoveLabelsByUniqueAttribute204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityRemoveLabelsByUniqueAttributeBodyParam { + body: string[]; +} + +// @public (undocumented) +export interface EntityRemoveLabelsByUniqueAttributeDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityRemoveLabelsByUniqueAttributeParameters = EntityRemoveLabelsByUniqueAttributeQueryParam & EntityRemoveLabelsByUniqueAttributeBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityRemoveLabelsByUniqueAttributeQueryParam { + // (undocumented) + queryParameters?: EntityRemoveLabelsByUniqueAttributeQueryParamProperties; +} + +// @public (undocumented) +export interface EntityRemoveLabelsByUniqueAttributeQueryParamProperties { + "attr:qualifiedName"?: string; +} + +// @public (undocumented) +export interface EntityRemoveLabelsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityRemoveLabelsParameters = EntityRemoveLabelsBodyParam & RequestParameters; + +// @public +export interface EntitySetLabels204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntitySetLabelsBodyParam { + body: string[]; +} + +// @public +export interface EntitySetLabelsByUniqueAttribute204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntitySetLabelsByUniqueAttributeBodyParam { + body: string[]; +} + +// @public (undocumented) +export interface EntitySetLabelsByUniqueAttributeDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntitySetLabelsByUniqueAttributeParameters = EntitySetLabelsByUniqueAttributeQueryParam & EntitySetLabelsByUniqueAttributeBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntitySetLabelsByUniqueAttributeQueryParam { + // (undocumented) + queryParameters?: EntitySetLabelsByUniqueAttributeQueryParamProperties; +} + +// @public (undocumented) +export interface EntitySetLabelsByUniqueAttributeQueryParamProperties { + "attr:qualifiedName"?: string; +} + +// @public (undocumented) +export interface EntitySetLabelsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntitySetLabelsParameters = EntitySetLabelsBodyParam & RequestParameters; + +// @public +export interface EntityTypeFilter extends SearchFilterParent { + entityType: string; + includeSubTypes?: boolean; + kind: "EntityTypeFilter"; +} + +// @public +export interface EntityUpdateClassifications204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityUpdateClassificationsBodyParam { + body: Array; +} + +// @public +export interface EntityUpdateClassificationsByUniqueAttribute204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface EntityUpdateClassificationsByUniqueAttributeBodyParam { + body: Array; +} + +// @public (undocumented) +export interface EntityUpdateClassificationsByUniqueAttributeDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityUpdateClassificationsByUniqueAttributeParameters = EntityUpdateClassificationsByUniqueAttributeQueryParam & EntityUpdateClassificationsByUniqueAttributeBodyParam & RequestParameters; + +// @public (undocumented) +export interface EntityUpdateClassificationsByUniqueAttributeQueryParam { + // (undocumented) + queryParameters?: EntityUpdateClassificationsByUniqueAttributeQueryParamProperties; +} + +// @public (undocumented) +export interface EntityUpdateClassificationsByUniqueAttributeQueryParamProperties { + "attr:qualifiedName"?: string; +} + +// @public (undocumented) +export interface EntityUpdateClassificationsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type EntityUpdateClassificationsParameters = EntityUpdateClassificationsBodyParam & RequestParameters; + +// @public +export interface ExistsFilter extends SearchFilterParent { + exists: string; + kind: "ExistsFilter"; +} + +// @public +export interface FileExtensionFilter extends SearchFilterParent { + fileExtension: string; + kind: "FileExtensionFilter"; +} + +// @public +export interface GlossaryAssignTermToEntities204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface GlossaryAssignTermToEntitiesBodyParam { + body: Array; +} + +// @public (undocumented) +export interface GlossaryAssignTermToEntitiesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryAssignTermToEntitiesParameters = GlossaryAssignTermToEntitiesBodyParam & RequestParameters; + +// @public +export interface GlossaryCreate200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryCreateBodyParam { + body: AtlasGlossary; +} + +// @public (undocumented) +export interface GlossaryCreateCategories { + post(options: GlossaryCreateCategoriesParameters): StreamableMethod; +} + +// @public +export interface GlossaryCreateCategories200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryCreateCategoriesBodyParam { + body: Array; +} + +// @public (undocumented) +export interface GlossaryCreateCategoriesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryCreateCategoriesParameters = GlossaryCreateCategoriesBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryCreateCategory { + post(options: GlossaryCreateCategoryParameters): StreamableMethod; +} + +// @public +export interface GlossaryCreateCategory200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryCategoryOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryCreateCategoryBodyParam { + body: AtlasGlossaryCategory; +} + +// @public (undocumented) +export interface GlossaryCreateCategoryDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryCreateCategoryParameters = GlossaryCreateCategoryBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryCreateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryCreateParameters = GlossaryCreateBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryCreateTerm { + post(options: GlossaryCreateTermParameters): StreamableMethod; +} + +// @public +export interface GlossaryCreateTerm200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryTermOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryCreateTermBodyParam { + body: AtlasGlossaryTerm; +} + +// @public (undocumented) +export interface GlossaryCreateTermDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryCreateTermParameters = GlossaryCreateTermQueryParam & GlossaryCreateTermBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryCreateTermQueryParam { + // (undocumented) + queryParameters?: GlossaryCreateTermQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryCreateTermQueryParamProperties { + includeTermHierarchy?: boolean; +} + +// @public (undocumented) +export interface GlossaryCreateTerms { + post(options: GlossaryCreateTermsParameters): StreamableMethod; +} + +// @public +export interface GlossaryCreateTerms200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryCreateTermsBodyParam { + body: Array; +} + +// @public (undocumented) +export interface GlossaryCreateTermsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryCreateTermsParameters = GlossaryCreateTermsQueryParam & GlossaryCreateTermsBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryCreateTermsQueryParam { + // (undocumented) + queryParameters?: GlossaryCreateTermsQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryCreateTermsQueryParamProperties { + includeTermHierarchy?: boolean; +} + +// @public +export interface GlossaryDeleteCategory204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface GlossaryDeleteCategoryDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryDeleteCategoryParameters = RequestParameters; + +// @public +export interface GlossaryDeleteOperation204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface GlossaryDeleteOperationDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryDeleteParameters = RequestParameters; + +// @public +export interface GlossaryDeleteTerm204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public +export interface GlossaryDeleteTermAssignmentFromEntities204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface GlossaryDeleteTermAssignmentFromEntitiesBodyParam { + body: Array; +} + +// @public (undocumented) +export interface GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryDeleteTermAssignmentFromEntitiesParameters = GlossaryDeleteTermAssignmentFromEntitiesBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryDeleteTermDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryDeleteTermParameters = RequestParameters; + +// @public +export interface GlossaryFilter extends SearchFilterParent { + glossaryType: string; + kind: "GlossaryFilter"; +} + +// @public (undocumented) +export interface GlossaryGet { + delete(options?: GlossaryDeleteParameters): StreamableMethod; + get(options?: GlossaryGetParameters): StreamableMethod; + put(options: GlossaryUpdateParameters): StreamableMethod; +} + +// @public +export interface GlossaryGet200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryGetCategory { + delete(options?: GlossaryDeleteCategoryParameters): StreamableMethod; + get(options?: GlossaryGetCategoryParameters): StreamableMethod; + put(options: GlossaryUpdateCategoryParameters): StreamableMethod; +} + +// @public +export interface GlossaryGetCategory200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryCategoryOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryGetCategoryDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryGetCategoryParameters = RequestParameters; + +// @public (undocumented) +export interface GlossaryGetDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export interface GlossaryGetDetailed { + get(options?: GlossaryGetDetailedParameters): StreamableMethod; +} + +// @public +export interface GlossaryGetDetailed200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryExtInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryGetDetailedDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryGetDetailedParameters = RequestParameters; + +// @public (undocumented) +export type GlossaryGetParameters = RequestParameters; + +// @public (undocumented) +export interface GlossaryGetTerm { + delete(options?: GlossaryDeleteTermParameters): StreamableMethod; + get(options?: GlossaryGetTermParameters): StreamableMethod; + put(options: GlossaryUpdateTermParameters): StreamableMethod; +} + +// @public +export interface GlossaryGetTerm200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryTermOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryGetTermDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryGetTermParameters = RequestParameters; + +// @public (undocumented) +export interface GlossaryList { + get(options?: GlossaryListParameters): StreamableMethod; + post(options: GlossaryCreateParameters): StreamableMethod; +} + +// @public +export interface GlossaryList200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListCategories { + get(options?: GlossaryListCategoriesParameters): StreamableMethod; +} + +// @public +export interface GlossaryListCategories200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListCategoriesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export interface GlossaryListCategoriesHeaders { + get(options?: GlossaryListCategoriesHeadersParameters): StreamableMethod; +} + +// @public +export interface GlossaryListCategoriesHeaders200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListCategoriesHeadersDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryListCategoriesHeadersParameters = GlossaryListCategoriesHeadersQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListCategoriesHeadersQueryParam { + // (undocumented) + queryParameters?: GlossaryListCategoriesHeadersQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListCategoriesHeadersQueryParamProperties { + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export type GlossaryListCategoriesParameters = GlossaryListCategoriesQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListCategoriesQueryParam { + // (undocumented) + queryParameters?: GlossaryListCategoriesQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListCategoriesQueryParamProperties { + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export interface GlossaryListCategoryTerms { + get(options?: GlossaryListCategoryTermsParameters): StreamableMethod; +} + +// @public +export interface GlossaryListCategoryTerms200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListCategoryTermsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryListCategoryTermsParameters = GlossaryListCategoryTermsQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListCategoryTermsQueryParam { + // (undocumented) + queryParameters?: GlossaryListCategoryTermsQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListCategoryTermsQueryParamProperties { + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export interface GlossaryListDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export interface GlossaryListEntitiesAssignedWithTerm { + delete(options: GlossaryDeleteTermAssignmentFromEntitiesParameters): StreamableMethod; + get(options?: GlossaryListEntitiesAssignedWithTermParameters): StreamableMethod; + post(options: GlossaryAssignTermToEntitiesParameters): StreamableMethod; +} + +// @public +export interface GlossaryListEntitiesAssignedWithTerm200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListEntitiesAssignedWithTermDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryListEntitiesAssignedWithTermParameters = GlossaryListEntitiesAssignedWithTermQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListEntitiesAssignedWithTermQueryParam { + // (undocumented) + queryParameters?: GlossaryListEntitiesAssignedWithTermQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListEntitiesAssignedWithTermQueryParamProperties { + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export type GlossaryListParameters = GlossaryListQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListQueryParam { + // (undocumented) + queryParameters?: GlossaryListQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListQueryParamProperties { + ignoreTermsAndCategories?: boolean; + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export interface GlossaryListRelatedCategories { + get(options?: GlossaryListRelatedCategoriesParameters): StreamableMethod; +} + +// @public +export interface GlossaryListRelatedCategories200Response extends HttpResponse { + // (undocumented) + body: Record>; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListRelatedCategoriesDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryListRelatedCategoriesParameters = GlossaryListRelatedCategoriesQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListRelatedCategoriesQueryParam { + // (undocumented) + queryParameters?: GlossaryListRelatedCategoriesQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListRelatedCategoriesQueryParamProperties { + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export interface GlossaryListRelatedTerms { + get(options?: GlossaryListRelatedTermsParameters): StreamableMethod; +} + +// @public +export interface GlossaryListRelatedTerms200Response extends HttpResponse { + // (undocumented) + body: Record>; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListRelatedTermsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryListRelatedTermsParameters = GlossaryListRelatedTermsQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListRelatedTermsQueryParam { + // (undocumented) + queryParameters?: GlossaryListRelatedTermsQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListRelatedTermsQueryParamProperties { + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export interface GlossaryListTermHeaders { + get(options?: GlossaryListTermHeadersParameters): StreamableMethod; +} + +// @public +export interface GlossaryListTermHeaders200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListTermHeadersDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryListTermHeadersParameters = GlossaryListTermHeadersQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListTermHeadersQueryParam { + // (undocumented) + queryParameters?: GlossaryListTermHeadersQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListTermHeadersQueryParamProperties { + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export interface GlossaryListTerms { + get(options?: GlossaryListTermsParameters): StreamableMethod; +} + +// @public +export interface GlossaryListTerms200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryListTermsDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryListTermsParameters = GlossaryListTermsQueryParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryListTermsQueryParam { + // (undocumented) + queryParameters?: GlossaryListTermsQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryListTermsQueryParamProperties { + limit?: number; + offset?: number; + sort?: string; +} + +// @public (undocumented) +export interface GlossaryPartialUpdate { + put(options: GlossaryPartialUpdateParameters): StreamableMethod; +} + +// @public +export interface GlossaryPartialUpdate200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateBodyParam { + body: unknown; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateCategory { + put(options: GlossaryPartialUpdateCategoryParameters): StreamableMethod; +} + +// @public +export interface GlossaryPartialUpdateCategory200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryCategoryOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateCategoryBodyParam { + body: unknown; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateCategoryDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryPartialUpdateCategoryParameters = GlossaryPartialUpdateCategoryBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryPartialUpdateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryPartialUpdateParameters = GlossaryPartialUpdateQueryParam & GlossaryPartialUpdateBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryPartialUpdateQueryParam { + // (undocumented) + queryParameters?: GlossaryPartialUpdateQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateQueryParamProperties { + ignoreTermsAndCategories?: boolean; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateTerm { + put(options: GlossaryPartialUpdateTermParameters): StreamableMethod; +} + +// @public +export interface GlossaryPartialUpdateTerm200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryTermOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateTermBodyParam { + body: unknown; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateTermDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryPartialUpdateTermParameters = GlossaryPartialUpdateTermQueryParam & GlossaryPartialUpdateTermBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryPartialUpdateTermQueryParam { + // (undocumented) + queryParameters?: GlossaryPartialUpdateTermQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryPartialUpdateTermQueryParamProperties { + includeTermHierarchy?: boolean; +} + +// @public +export interface GlossaryUpdate200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryUpdateBodyParam { + body: AtlasGlossary; +} + +// @public +export interface GlossaryUpdateCategory200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryCategoryOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryUpdateCategoryBodyParam { + body: AtlasGlossaryCategory; +} + +// @public (undocumented) +export interface GlossaryUpdateCategoryDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryUpdateCategoryParameters = GlossaryUpdateCategoryBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryUpdateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryUpdateParameters = GlossaryUpdateQueryParam & GlossaryUpdateBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryUpdateQueryParam { + // (undocumented) + queryParameters?: GlossaryUpdateQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryUpdateQueryParamProperties { + ignoreTermsAndCategories?: boolean; +} + +// @public +export interface GlossaryUpdateTerm200Response extends HttpResponse { + // (undocumented) + body: AtlasGlossaryTermOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface GlossaryUpdateTermBodyParam { + body: AtlasGlossaryTerm; +} + +// @public (undocumented) +export interface GlossaryUpdateTermDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type GlossaryUpdateTermParameters = GlossaryUpdateTermQueryParam & GlossaryUpdateTermBodyParam & RequestParameters; + +// @public (undocumented) +export interface GlossaryUpdateTermQueryParam { + // (undocumented) + queryParameters?: GlossaryUpdateTermQueryParamProperties; +} + +// @public (undocumented) +export interface GlossaryUpdateTermQueryParamProperties { + includeTermHierarchy?: boolean; +} + +// @public +export interface IdFilter extends SearchFilterParent { + id: string; + kind: "IdFilter"; +} + +// @public +export interface ImportInfoOutput { + childObjectName?: string; + importStatus?: string; + parentObjectName?: string; + remarks?: string; +} + +// @public (undocumented) +export function isUnexpected(response: EntityCreateOrUpdate200Response | EntityCreateOrUpdateDefaultResponse): response is EntityCreateOrUpdateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityListByGuids200Response | EntityListByGuidsDefaultResponse): response is EntityListByGuidsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityBulkCreateOrUpdate200Response | EntityBulkCreateOrUpdateDefaultResponse): response is EntityBulkCreateOrUpdateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityBulkDelete200Response | EntityBulkDeleteDefaultResponse): response is EntityBulkDeleteDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityAddClassification204Response | EntityAddClassificationDefaultResponse): response is EntityAddClassificationDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityGet200Response | EntityGetDefaultResponse): response is EntityGetDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityPartialUpdateAttributeByGuid200Response | EntityPartialUpdateAttributeByGuidDefaultResponse): response is EntityPartialUpdateAttributeByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityDeleteOperation200Response | EntityDeleteOperationDefaultResponse): response is EntityDeleteOperationDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityGetClassification200Response | EntityGetClassificationDefaultResponse): response is EntityGetClassificationDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityRemoveClassification204Response | EntityRemoveClassificationDefaultResponse): response is EntityRemoveClassificationDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityGetClassifications200Response | EntityGetClassificationsDefaultResponse): response is EntityGetClassificationsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityAddClassifications204Response | EntityAddClassificationsDefaultResponse): response is EntityAddClassificationsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityUpdateClassifications204Response | EntityUpdateClassificationsDefaultResponse): response is EntityUpdateClassificationsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityGetByUniqueAttributes200Response | EntityGetByUniqueAttributesDefaultResponse): response is EntityGetByUniqueAttributesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityPartialUpdateByUniqueAttributes200Response | EntityPartialUpdateByUniqueAttributesDefaultResponse): response is EntityPartialUpdateByUniqueAttributesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityDeleteByUniqueAttribute200Response | EntityDeleteByUniqueAttributeDefaultResponse): response is EntityDeleteByUniqueAttributeDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityRemoveClassificationByUniqueAttribute204Response | EntityRemoveClassificationByUniqueAttributeDefaultResponse): response is EntityRemoveClassificationByUniqueAttributeDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityAddClassificationsByUniqueAttribute204Response | EntityAddClassificationsByUniqueAttributeDefaultResponse): response is EntityAddClassificationsByUniqueAttributeDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityUpdateClassificationsByUniqueAttribute204Response | EntityUpdateClassificationsByUniqueAttributeDefaultResponse): response is EntityUpdateClassificationsByUniqueAttributeDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityBulkSetClassifications200Response | EntityBulkSetClassificationsDefaultResponse): response is EntityBulkSetClassificationsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityListByUniqueAttributes200Response | EntityListByUniqueAttributesDefaultResponse): response is EntityListByUniqueAttributesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityGetHeader200Response | EntityGetHeaderDefaultResponse): response is EntityGetHeaderDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityRemoveBusinessMetadata204Response | EntityRemoveBusinessMetadataDefaultResponse): response is EntityRemoveBusinessMetadataDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityAddOrUpdateBusinessMetadata204Response | EntityAddOrUpdateBusinessMetadataDefaultResponse): response is EntityAddOrUpdateBusinessMetadataDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityRemoveBusinessMetadataAttributes204Response | EntityRemoveBusinessMetadataAttributesDefaultResponse): response is EntityRemoveBusinessMetadataAttributesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityAddOrUpdateBusinessMetadataAttributes204Response | EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse): response is EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityGetSampleBusinessMetadataTemplate200Response | EntityGetSampleBusinessMetadataTemplateDefaultResponse): response is EntityGetSampleBusinessMetadataTemplateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityImportBusinessMetadata200Response | EntityImportBusinessMetadataDefaultResponse): response is EntityImportBusinessMetadataDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityRemoveLabels204Response | EntityRemoveLabelsDefaultResponse): response is EntityRemoveLabelsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntitySetLabels204Response | EntitySetLabelsDefaultResponse): response is EntitySetLabelsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityAddLabel204Response | EntityAddLabelDefaultResponse): response is EntityAddLabelDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityRemoveLabelsByUniqueAttribute204Response | EntityRemoveLabelsByUniqueAttributeDefaultResponse): response is EntityRemoveLabelsByUniqueAttributeDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntitySetLabelsByUniqueAttribute204Response | EntitySetLabelsByUniqueAttributeDefaultResponse): response is EntitySetLabelsByUniqueAttributeDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityAddLabelsByUniqueAttribute204Response | EntityAddLabelsByUniqueAttributeDefaultResponse): response is EntityAddLabelsByUniqueAttributeDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: EntityMoveEntitiesToCollection200Response | EntityMoveEntitiesToCollectionDefaultResponse): response is EntityMoveEntitiesToCollectionDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryList200Response | GlossaryListDefaultResponse): response is GlossaryListDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryCreate200Response | GlossaryCreateDefaultResponse): response is GlossaryCreateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryCreateCategories200Response | GlossaryCreateCategoriesDefaultResponse): response is GlossaryCreateCategoriesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryCreateCategory200Response | GlossaryCreateCategoryDefaultResponse): response is GlossaryCreateCategoryDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryGetCategory200Response | GlossaryGetCategoryDefaultResponse): response is GlossaryGetCategoryDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryUpdateCategory200Response | GlossaryUpdateCategoryDefaultResponse): response is GlossaryUpdateCategoryDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryDeleteCategory204Response | GlossaryDeleteCategoryDefaultResponse): response is GlossaryDeleteCategoryDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryPartialUpdateCategory200Response | GlossaryPartialUpdateCategoryDefaultResponse): response is GlossaryPartialUpdateCategoryDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryListRelatedCategories200Response | GlossaryListRelatedCategoriesDefaultResponse): response is GlossaryListRelatedCategoriesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryListCategoryTerms200Response | GlossaryListCategoryTermsDefaultResponse): response is GlossaryListCategoryTermsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryCreateTerm200Response | GlossaryCreateTermDefaultResponse): response is GlossaryCreateTermDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryGetTerm200Response | GlossaryGetTermDefaultResponse): response is GlossaryGetTermDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryUpdateTerm200Response | GlossaryUpdateTermDefaultResponse): response is GlossaryUpdateTermDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryDeleteTerm204Response | GlossaryDeleteTermDefaultResponse): response is GlossaryDeleteTermDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryPartialUpdateTerm200Response | GlossaryPartialUpdateTermDefaultResponse): response is GlossaryPartialUpdateTermDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryCreateTerms200Response | GlossaryCreateTermsDefaultResponse): response is GlossaryCreateTermsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryListEntitiesAssignedWithTerm200Response | GlossaryListEntitiesAssignedWithTermDefaultResponse): response is GlossaryListEntitiesAssignedWithTermDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryAssignTermToEntities204Response | GlossaryAssignTermToEntitiesDefaultResponse): response is GlossaryAssignTermToEntitiesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryDeleteTermAssignmentFromEntities204Response | GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse): response is GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryListRelatedTerms200Response | GlossaryListRelatedTermsDefaultResponse): response is GlossaryListRelatedTermsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryGet200Response | GlossaryGetDefaultResponse): response is GlossaryGetDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryUpdate200Response | GlossaryUpdateDefaultResponse): response is GlossaryUpdateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryDeleteOperation204Response | GlossaryDeleteOperationDefaultResponse): response is GlossaryDeleteOperationDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryListCategories200Response | GlossaryListCategoriesDefaultResponse): response is GlossaryListCategoriesDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryListCategoriesHeaders200Response | GlossaryListCategoriesHeadersDefaultResponse): response is GlossaryListCategoriesHeadersDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryGetDetailed200Response | GlossaryGetDetailedDefaultResponse): response is GlossaryGetDetailedDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryPartialUpdate200Response | GlossaryPartialUpdateDefaultResponse): response is GlossaryPartialUpdateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryListTerms200Response | GlossaryListTermsDefaultResponse): response is GlossaryListTermsDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: GlossaryListTermHeaders200Response | GlossaryListTermHeadersDefaultResponse): response is GlossaryListTermHeadersDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: DiscoveryQuery200Response | DiscoveryQueryDefaultResponse): response is DiscoveryQueryDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: DiscoverySuggest200Response | DiscoverySuggestDefaultResponse): response is DiscoverySuggestDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: DiscoveryAutoComplete200Response | DiscoveryAutoCompleteDefaultResponse): response is DiscoveryAutoCompleteDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: LineageGet200Response | LineageGetDefaultResponse): response is LineageGetDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: LineageGetNextPage200Response | LineageGetNextPageDefaultResponse): response is LineageGetNextPageDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: LineageGetByUniqueAttribute200Response | LineageGetByUniqueAttributeDefaultResponse): response is LineageGetByUniqueAttributeDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: RelationshipCreate200Response | RelationshipCreateDefaultResponse): response is RelationshipCreateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: RelationshipUpdate200Response | RelationshipUpdateDefaultResponse): response is RelationshipUpdateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: RelationshipGet200Response | RelationshipGetDefaultResponse): response is RelationshipGetDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: RelationshipDeleteOperation204Response | RelationshipDeleteOperationDefaultResponse): response is RelationshipDeleteOperationDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetBusinessMetadataDefByGuid200Response | TypeGetBusinessMetadataDefByGuidDefaultResponse): response is TypeGetBusinessMetadataDefByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetBusinessMetadataDefByName200Response | TypeGetBusinessMetadataDefByNameDefaultResponse): response is TypeGetBusinessMetadataDefByNameDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetClassificationDefByGuid200Response | TypeGetClassificationDefByGuidDefaultResponse): response is TypeGetClassificationDefByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetClassificationDefByName200Response | TypeGetClassificationDefByNameDefaultResponse): response is TypeGetClassificationDefByNameDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetEntityDefByGuid200Response | TypeGetEntityDefByGuidDefaultResponse): response is TypeGetEntityDefByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetEntityDefByName200Response | TypeGetEntityDefByNameDefaultResponse): response is TypeGetEntityDefByNameDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetEnumDefByGuid200Response | TypeGetEnumDefByGuidDefaultResponse): response is TypeGetEnumDefByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetEnumDefByName200Response | TypeGetEnumDefByNameDefaultResponse): response is TypeGetEnumDefByNameDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetRelationshipDefByGuid200Response | TypeGetRelationshipDefByGuidDefaultResponse): response is TypeGetRelationshipDefByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetRelationshipDefByName200Response | TypeGetRelationshipDefByNameDefaultResponse): response is TypeGetRelationshipDefByNameDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetStructDefByGuid200Response | TypeGetStructDefByGuidDefaultResponse): response is TypeGetStructDefByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetStructDefByName200Response | TypeGetStructDefByNameDefaultResponse): response is TypeGetStructDefByNameDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetByGuid200Response | TypeGetByGuidDefaultResponse): response is TypeGetByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetByName200Response | TypeGetByNameDefaultResponse): response is TypeGetByNameDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeDeleteOperation204Response | TypeDeleteOperationDefaultResponse): response is TypeDeleteOperationDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeList200Response | TypeListDefaultResponse): response is TypeListDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeBulkCreate200Response | TypeBulkCreateDefaultResponse): response is TypeBulkCreateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeBulkUpdate200Response | TypeBulkUpdateDefaultResponse): response is TypeBulkUpdateDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeBulkDelete204Response | TypeBulkDeleteDefaultResponse): response is TypeBulkDeleteDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeListHeaders200Response | TypeListHeadersDefaultResponse): response is TypeListHeadersDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetTermTemplateDefByGuid200Response | TypeGetTermTemplateDefByGuidDefaultResponse): response is TypeGetTermTemplateDefByGuidDefaultResponse; + +// @public (undocumented) +export function isUnexpected(response: TypeGetTermTemplateDefByName200Response | TypeGetTermTemplateDefByNameDefaultResponse): response is TypeGetTermTemplateDefByNameDefaultResponse; + +// @public +export interface LabelFilter extends SearchFilterParent { + includeSubLabels?: boolean; + kind: "LabelFilter"; + label: string; +} + +// @public (undocumented) +export interface LineageGet { + get(options: LineageGetParameters): StreamableMethod; +} + +// @public +export interface LineageGet200Response extends HttpResponse { + // (undocumented) + body: AtlasLineageInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface LineageGetByUniqueAttribute { + get(options: LineageGetByUniqueAttributeParameters): StreamableMethod; +} + +// @public +export interface LineageGetByUniqueAttribute200Response extends HttpResponse { + // (undocumented) + body: AtlasLineageInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface LineageGetByUniqueAttributeDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type LineageGetByUniqueAttributeParameters = LineageGetByUniqueAttributeQueryParam & RequestParameters; + +// @public (undocumented) +export interface LineageGetByUniqueAttributeQueryParam { + // (undocumented) + queryParameters: LineageGetByUniqueAttributeQueryParamProperties; +} + +// @public (undocumented) +export interface LineageGetByUniqueAttributeQueryParamProperties { + "attr:qualifiedName"?: string; + depth?: number; + direction: string; +} + +// @public (undocumented) +export interface LineageGetDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export interface LineageGetNextPage { + get(options: LineageGetNextPageParameters): StreamableMethod; +} + +// @public +export interface LineageGetNextPage200Response extends HttpResponse { + // (undocumented) + body: AtlasLineageInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface LineageGetNextPageDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type LineageGetNextPageParameters = LineageGetNextPageQueryParam & RequestParameters; + +// @public (undocumented) +export interface LineageGetNextPageQueryParam { + // (undocumented) + queryParameters: LineageGetNextPageQueryParamProperties; +} + +// @public (undocumented) +export interface LineageGetNextPageQueryParamProperties { + direction: string; + limit?: number; + offset?: number; +} + +// @public (undocumented) +export type LineageGetParameters = LineageGetQueryParam & RequestParameters; + +// @public (undocumented) +export interface LineageGetQueryParam { + // (undocumented) + queryParameters: LineageGetQueryParamProperties; +} + +// @public (undocumented) +export interface LineageGetQueryParamProperties { + depth?: number; + direction: string; +} + +// @public +export interface LineageRelationOutput { + fromEntityId?: string; + relationshipId?: string; + toEntityId?: string; +} + +// @public +export interface MoveEntitiesContent { + entityGuids?: string[]; +} + +// @public +export interface NotFilter extends SearchFilterParent { + kind: "NotFilter"; + not: SearchFilter; +} + +// @public +export interface NumberFormat { + availableLocales?: string[]; + currency?: string; + currencyInstance?: NumberFormat; + groupingUsed?: boolean; + instance?: NumberFormat; + integerInstance?: NumberFormat; + maximumFractionDigits?: number; + maximumIntegerDigits?: number; + minimumFractionDigits?: number; + minimumIntegerDigits?: number; + numberInstance?: NumberFormat; + parseIntegerOnly?: boolean; + percentInstance?: NumberFormat; + roundingMode?: string; +} + +// @public +export interface NumberFormatOutput { + availableLocales?: string[]; + currency?: string; + currencyInstance?: NumberFormatOutput; + groupingUsed?: boolean; + instance?: NumberFormatOutput; + integerInstance?: NumberFormatOutput; + maximumFractionDigits?: number; + maximumIntegerDigits?: number; + minimumFractionDigits?: number; + minimumIntegerDigits?: number; + numberInstance?: NumberFormatOutput; + parseIntegerOnly?: boolean; + percentInstance?: NumberFormatOutput; + roundingMode?: string; +} + +// @public +export interface ObjectTypeFilter extends SearchFilterParent { + kind: "ObjectTypeFilter"; + objectType: string; +} + +// @public +export interface OrFilter extends SearchFilterParent { + kind: "OrFilter"; + or: Array; +} + +// @public +export interface ParentRelationOutput { + childEntityId?: string; + parentEntityId?: string; + relationshipId?: string; +} + +// @public +export interface PathFilter extends SearchFilterParent { + isParent?: boolean; + kind: "PathFilter"; + path: string; +} + +// @public (undocumented) +export type PurviewDataMapClient = Client & { + path: Routes; +}; + +// @public +export interface PurviewObjectId { + displayText?: string; + guid?: string; + itemPath?: string; + name?: string; + properties?: Record; + resourceId?: string; + typeName?: string; + uniqueAttributes?: Record; +} + +// @public +export interface PurviewObjectIdOutput { + displayText?: string; + guid?: string; + itemPath?: string; + name?: string; + properties?: Record; + resourceId?: string; + typeName?: string; + uniqueAttributes?: Record; +} + +// @public (undocumented) +export interface RelationshipCreate { + post(options: RelationshipCreateParameters): StreamableMethod; + put(options: RelationshipUpdateParameters): StreamableMethod; +} + +// @public +export interface RelationshipCreate200Response extends HttpResponse { + // (undocumented) + body: AtlasRelationshipOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface RelationshipCreateBodyParam { + body: AtlasRelationship; +} + +// @public (undocumented) +export interface RelationshipCreateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type RelationshipCreateParameters = RelationshipCreateBodyParam & RequestParameters; + +// @public +export interface RelationshipDeleteOperation204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface RelationshipDeleteOperationDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type RelationshipDeleteParameters = RequestParameters; + +// @public (undocumented) +export interface RelationshipGet { + delete(options?: RelationshipDeleteParameters): StreamableMethod; + get(options?: RelationshipGetParameters): StreamableMethod; +} + +// @public +export interface RelationshipGet200Response extends HttpResponse { + // (undocumented) + body: AtlasRelationshipWithExtInfoOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface RelationshipGetDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type RelationshipGetParameters = RelationshipGetQueryParam & RequestParameters; + +// @public (undocumented) +export interface RelationshipGetQueryParam { + // (undocumented) + queryParameters?: RelationshipGetQueryParamProperties; +} + +// @public (undocumented) +export interface RelationshipGetQueryParamProperties { + extendedInfo?: boolean; +} + +// @public +export interface RelationshipUpdate200Response extends HttpResponse { + // (undocumented) + body: AtlasRelationshipOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface RelationshipUpdateBodyParam { + body: AtlasRelationship; +} + +// @public (undocumented) +export interface RelationshipUpdateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type RelationshipUpdateParameters = RelationshipUpdateBodyParam & RequestParameters; + +// @public +export interface ResourceLink { + displayName?: string; + url?: string; +} + +// @public +export interface ResourceLinkOutput { + displayName?: string; + url?: string; +} + +// @public (undocumented) +export interface Routes { + (path: "/atlas/v2/entity"): EntityCreateOrUpdate; + (path: "/atlas/v2/entity/bulk"): EntityListByGuids; + (path: "/atlas/v2/entity/bulk/classification"): EntityAddClassification; + (path: "/atlas/v2/entity/guid/{guid}", guid: string): EntityGet; + (path: "/atlas/v2/entity/guid/{guid}/classification/{classificationName}", guid: string, classificationName: string): EntityGetClassification; + (path: "/atlas/v2/entity/guid/{guid}/classifications", guid: string): EntityGetClassifications; + (path: "/atlas/v2/entity/uniqueAttribute/type/{typeName}", typeName: string): EntityGetByUniqueAttributes; + (path: "/atlas/v2/entity/uniqueAttribute/type/{typeName}/classification/{classificationName}", typeName: string, classificationName: string): EntityRemoveClassificationByUniqueAttribute; + (path: "/atlas/v2/entity/uniqueAttribute/type/{typeName}/classifications", typeName: string): EntityAddClassificationsByUniqueAttribute; + (path: "/atlas/v2/entity/bulk/setClassifications"): EntityBulkSetClassifications; + (path: "/atlas/v2/entity/bulk/uniqueAttribute/type/{typeName}", typeName: string): EntityListByUniqueAttributes; + (path: "/atlas/v2/entity/guid/{guid}/header", guid: string): EntityGetHeader; + (path: "/atlas/v2/entity/guid/{guid}/businessmetadata", guid: string): EntityRemoveBusinessMetadata; + (path: "/atlas/v2/entity/guid/{guid}/businessmetadata/{bmName}", bmName: string, guid: string): EntityRemoveBusinessMetadataAttributes; + (path: "/atlas/v2/entity/businessmetadata/import/template"): EntityGetSampleBusinessMetadataTemplate; + (path: "/atlas/v2/entity/businessmetadata/import"): EntityImportBusinessMetadata; + (path: "/atlas/v2/entity/guid/{guid}/labels", guid: string): EntityRemoveLabels; + (path: "/atlas/v2/entity/uniqueAttribute/type/{typeName}/labels", typeName: string): EntityRemoveLabelsByUniqueAttribute; + (path: "/entity/moveTo"): EntityMoveEntitiesToCollection; + (path: "/atlas/v2/glossary"): GlossaryList; + (path: "/atlas/v2/glossary/categories"): GlossaryCreateCategories; + (path: "/atlas/v2/glossary/category"): GlossaryCreateCategory; + (path: "/atlas/v2/glossary/category/{categoryGuid}", categoryGuid: string): GlossaryGetCategory; + (path: "/atlas/v2/glossary/category/{categoryGuid}/partial", categoryGuid: string): GlossaryPartialUpdateCategory; + (path: "/atlas/v2/glossary/category/{categoryGuid}/related", categoryGuid: string): GlossaryListRelatedCategories; + (path: "/atlas/v2/glossary/category/{categoryGuid}/terms", categoryGuid: string): GlossaryListCategoryTerms; + (path: "/atlas/v2/glossary/term"): GlossaryCreateTerm; + (path: "/atlas/v2/glossary/term/{termGuid}", termGuid: string): GlossaryGetTerm; + (path: "/atlas/v2/glossary/term/{termGuid}/partial", termGuid: string): GlossaryPartialUpdateTerm; + (path: "/atlas/v2/glossary/terms"): GlossaryCreateTerms; + (path: "/atlas/v2/glossary/terms/{termGuid}/assignedEntities", termGuid: string): GlossaryListEntitiesAssignedWithTerm; + (path: "/atlas/v2/glossary/terms/{termGuid}/related", termGuid: string): GlossaryListRelatedTerms; + (path: "/atlas/v2/glossary/{glossaryGuid}", glossaryGuid: string): GlossaryGet; + (path: "/atlas/v2/glossary/{glossaryGuid}/categories", glossaryGuid: string): GlossaryListCategories; + (path: "/atlas/v2/glossary/{glossaryGuid}/categories/headers", glossaryGuid: string): GlossaryListCategoriesHeaders; + (path: "/atlas/v2/glossary/{glossaryGuid}/detailed", glossaryGuid: string): GlossaryGetDetailed; + (path: "/atlas/v2/glossary/{glossaryGuid}/partial", glossaryGuid: string): GlossaryPartialUpdate; + (path: "/atlas/v2/glossary/{glossaryGuid}/terms", glossaryGuid: string): GlossaryListTerms; + (path: "/atlas/v2/glossary/{glossaryGuid}/terms/headers", glossaryGuid: string): GlossaryListTermHeaders; + (path: "/search/query"): DiscoveryQuery; + (path: "/search/suggest"): DiscoverySuggest; + (path: "/search/autocomplete"): DiscoveryAutoComplete; + (path: "/atlas/v2/lineage/{guid}", guid: string): LineageGet; + (path: "/lineage/{guid}/next", guid: string): LineageGetNextPage; + (path: "/atlas/v2/lineage/uniqueAttribute/type/{typeName}", typeName: string): LineageGetByUniqueAttribute; + (path: "/atlas/v2/relationship"): RelationshipCreate; + (path: "/atlas/v2/relationship/guid/{guid}", guid: string): RelationshipGet; + (path: "/atlas/v2/types/businessmetadatadef/guid/{guid}", guid: string): TypeGetBusinessMetadataDefByGuid; + (path: "/atlas/v2/types/businessmetadatadef/name/{name}", name: string): TypeGetBusinessMetadataDefByName; + (path: "/atlas/v2/types/classificationdef/guid/{guid}", guid: string): TypeGetClassificationDefByGuid; + (path: "/atlas/v2/types/classificationdef/name/{name}", name: string): TypeGetClassificationDefByName; + (path: "/atlas/v2/types/entitydef/guid/{guid}", guid: string): TypeGetEntityDefByGuid; + (path: "/atlas/v2/types/entitydef/name/{name}", name: string): TypeGetEntityDefByName; + (path: "/atlas/v2/types/enumdef/guid/{guid}", guid: string): TypeGetEnumDefByGuid; + (path: "/atlas/v2/types/enumdef/name/{name}", name: string): TypeGetEnumDefByName; + (path: "/atlas/v2/types/relationshipdef/guid/{guid}", guid: string): TypeGetRelationshipDefByGuid; + (path: "/atlas/v2/types/relationshipdef/name/{name}", name: string): TypeGetRelationshipDefByName; + (path: "/atlas/v2/types/structdef/guid/{guid}", guid: string): TypeGetStructDefByGuid; + (path: "/atlas/v2/types/structdef/name/{name}", name: string): TypeGetStructDefByName; + (path: "/atlas/v2/types/typedef/guid/{guid}", guid: string): TypeGetByGuid; + (path: "/atlas/v2/types/typedef/name/{name}", name: string): TypeGetByName; + (path: "/atlas/v2/types/typedefs"): TypeList; + (path: "/atlas/v2/types/typedefs/headers"): TypeListHeaders; + (path: "/types/termtemplatedef/guid/{guid}", guid: string): TypeGetTermTemplateDefByGuid; + (path: "/types/termtemplatedef/name/{name}", name: string): TypeGetTermTemplateDefByName; +} + +// @public +export interface ScanInfoFilter extends SearchFilterParent { + dataSourceName?: string; + kind: "ScanInfoFilter"; + scanName?: string; +} + +// @public +export interface SearchContent { + continuationToken?: string; + facets?: Array; + filter?: unknown; + keywords?: string; + limit?: number; + orderby?: unknown[]; + taxonomySetting?: SearchRequestTaxonomySetting; +} + +// @public +export interface SearchFacetItem { + count?: number; + facet?: string; + sort?: SearchFacetSort; +} + +// @public +export interface SearchFacetItemValueOutput { + count?: number; + value?: string; +} + +// @public +export interface SearchFacetResultValueOutput { + assetType?: Array; + classification?: Array; + contactId?: Array; + contactType?: Array; + entityType?: Array; + glossaryType?: Array; + label?: Array; + term?: Array; + termStatus?: Array; + termTemplate?: Array; +} + +// @public +export interface SearchFacetSort { + count?: string; + value?: string; +} + +// @public +export type SearchFilter = AndFilter | NotFilter | OrFilter | AssetTypeFilter | AttributeFilter | ClassificationFilter | ClassificationCategoryFilter | CollectionIdFilter | ContactFilter | DomainIdFilter | ExistsFilter | FileExtensionFilter | LabelFilter | ObjectTypeFilter | PathFilter | ScanInfoFilter | GlossaryFilter | TermFilter | IdFilter | EntityTypeFilter | CreateTimeFilter | UpdateTimeFilter; + +// @public +export interface SearchFilterParent { + // (undocumented) + kind: string; +} + +// @public +export interface SearchHighlightsOutput { + description?: string[]; + entityType?: string[]; + id?: string[]; + name?: string[]; + qualifiedName?: string[]; +} + +// @public +export interface SearchRequestTaxonomySetting { + assetTypes?: string[]; + facet?: SearchFacetItem; +} + +// @public +export interface SearchResultOutput { + "@search.count"?: number; + "@search.count.approximate"?: boolean; + "@search.facets"?: SearchFacetResultValueOutput; + continuationToken?: string; + value?: Array; +} + +// @public +export interface SearchResultValueOutput { + "@search.highlights"?: SearchHighlightsOutput; + "@search.score"?: number; + assetType?: string[]; + classification?: string[]; + contact?: Array; + createTime?: number; + description?: string; + endorsement?: string; + entityType?: string; + glossary?: string; + glossaryType?: string; + id?: string; + label?: string[]; + longDescription?: string; + name?: string; + objectType?: string; + owner?: string; + qualifiedName?: string; + term?: Array; + termStatus?: string; + termTemplate?: string[]; + updateTime?: number; +} + +// @public +export interface SuggestContent { + filter?: SearchFilter; + keywords?: string; + limit?: number; +} + +// @public +export interface SuggestResultOutput { + value?: Array; +} + +// @public +export interface SuggestResultValueOutput { + "@search.score"?: number; + "@search.text"?: string; + assetType?: string[]; + classification?: string[]; + contact?: Array; + createTime?: number; + description?: string; + endorsement?: string; + entityType?: string; + glossary?: string; + glossaryType?: string; + id?: string; + label?: string[]; + longDescription?: string; + name?: string; + objectType?: string; + owner?: string; + qualifiedName?: string; + term?: Array; + termStatus?: string; + termTemplate?: string[]; + updateTime?: number; +} + +// @public +export interface TermFilter extends SearchFilterParent { + glossary?: string; + kind: "TermFilter"; + term?: string; + termGuid?: string; +} + +// @public +export interface TermSearchResultValueOutput { + glossaryName?: string; + guid?: string; + name?: string; +} + +// @public +export interface TermTemplateDef { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormat; + description?: string; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface TermTemplateDefOutput { + attributeDefs?: Array; + category?: string; + createdBy?: string; + createTime?: number; + dateFormatter?: DateFormatOutput; + description?: string; + guid?: string; + lastModifiedTS?: string; + name?: string; + options?: Record; + serviceType?: string; + typeVersion?: string; + updatedBy?: string; + updateTime?: number; + version?: number; +} + +// @public +export interface TimeBoundary { + endTime?: string; + startTime?: string; + timeZone?: string; +} + +// @public +export interface TimeBoundaryOutput { + endTime?: string; + startTime?: string; + timeZone?: string; +} + +// @public +export interface TimeZone { + availableIds?: string[]; + default?: TimeZone; + displayName?: string; + dstSavings?: number; + id?: string; + rawOffset?: number; +} + +// @public +export interface TimeZoneOutput { + availableIds?: string[]; + default?: TimeZoneOutput; + displayName?: string; + dstSavings?: number; + id?: string; + rawOffset?: number; +} + +// @public +export interface TypeBulkCreate200Response extends HttpResponse { + // (undocumented) + body: AtlasTypesDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeBulkCreateBodyParam { + body: AtlasTypesDef; +} + +// @public (undocumented) +export interface TypeBulkCreateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeBulkCreateParameters = TypeBulkCreateBodyParam & RequestParameters; + +// @public +export interface TypeBulkDelete204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface TypeBulkDeleteBodyParam { + body: AtlasTypesDef; +} + +// @public (undocumented) +export interface TypeBulkDeleteDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeBulkDeleteParameters = TypeBulkDeleteBodyParam & RequestParameters; + +// @public +export interface TypeBulkUpdate200Response extends HttpResponse { + // (undocumented) + body: AtlasTypesDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeBulkUpdateBodyParam { + body: AtlasTypesDef; +} + +// @public (undocumented) +export interface TypeBulkUpdateDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeBulkUpdateParameters = TypeBulkUpdateBodyParam & RequestParameters; + +// @public +export interface TypeDeleteOperation204Response extends HttpResponse { + // (undocumented) + status: "204"; +} + +// @public (undocumented) +export interface TypeDeleteOperationDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeDeleteParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetBusinessMetadataDefByGuid { + get(options?: TypeGetBusinessMetadataDefByGuidParameters): StreamableMethod; +} + +// @public +export interface TypeGetBusinessMetadataDefByGuid200Response extends HttpResponse { + // (undocumented) + body: AtlasBusinessMetadataDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetBusinessMetadataDefByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetBusinessMetadataDefByGuidParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetBusinessMetadataDefByName { + get(options?: TypeGetBusinessMetadataDefByNameParameters): StreamableMethod; +} + +// @public +export interface TypeGetBusinessMetadataDefByName200Response extends HttpResponse { + // (undocumented) + body: AtlasBusinessMetadataDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetBusinessMetadataDefByNameDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetBusinessMetadataDefByNameParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetByGuid { + get(options?: TypeGetByGuidParameters): StreamableMethod; +} + +// @public +export interface TypeGetByGuid200Response extends HttpResponse { + // (undocumented) + body: AtlasTypeDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetByGuidParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetByName { + delete(options?: TypeDeleteParameters): StreamableMethod; + get(options?: TypeGetByNameParameters): StreamableMethod; +} + +// @public +export interface TypeGetByName200Response extends HttpResponse { + // (undocumented) + body: AtlasTypeDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetByNameDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetByNameParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetClassificationDefByGuid { + get(options?: TypeGetClassificationDefByGuidParameters): StreamableMethod; +} + +// @public +export interface TypeGetClassificationDefByGuid200Response extends HttpResponse { + // (undocumented) + body: AtlasClassificationDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetClassificationDefByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetClassificationDefByGuidParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetClassificationDefByName { + get(options?: TypeGetClassificationDefByNameParameters): StreamableMethod; +} + +// @public +export interface TypeGetClassificationDefByName200Response extends HttpResponse { + // (undocumented) + body: AtlasClassificationDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetClassificationDefByNameDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetClassificationDefByNameParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetEntityDefByGuid { + get(options?: TypeGetEntityDefByGuidParameters): StreamableMethod; +} + +// @public +export interface TypeGetEntityDefByGuid200Response extends HttpResponse { + // (undocumented) + body: AtlasEntityDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetEntityDefByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetEntityDefByGuidParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetEntityDefByName { + get(options?: TypeGetEntityDefByNameParameters): StreamableMethod; +} + +// @public +export interface TypeGetEntityDefByName200Response extends HttpResponse { + // (undocumented) + body: AtlasEntityDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetEntityDefByNameDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetEntityDefByNameParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetEnumDefByGuid { + get(options?: TypeGetEnumDefByGuidParameters): StreamableMethod; +} + +// @public +export interface TypeGetEnumDefByGuid200Response extends HttpResponse { + // (undocumented) + body: AtlasEnumDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetEnumDefByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetEnumDefByGuidParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetEnumDefByName { + get(options?: TypeGetEnumDefByNameParameters): StreamableMethod; +} + +// @public +export interface TypeGetEnumDefByName200Response extends HttpResponse { + // (undocumented) + body: AtlasEnumDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetEnumDefByNameDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetEnumDefByNameParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetRelationshipDefByGuid { + get(options?: TypeGetRelationshipDefByGuidParameters): StreamableMethod; +} + +// @public +export interface TypeGetRelationshipDefByGuid200Response extends HttpResponse { + // (undocumented) + body: AtlasRelationshipDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetRelationshipDefByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetRelationshipDefByGuidParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetRelationshipDefByName { + get(options?: TypeGetRelationshipDefByNameParameters): StreamableMethod; +} + +// @public +export interface TypeGetRelationshipDefByName200Response extends HttpResponse { + // (undocumented) + body: AtlasRelationshipDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetRelationshipDefByNameDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetRelationshipDefByNameParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetStructDefByGuid { + get(options?: TypeGetStructDefByGuidParameters): StreamableMethod; +} + +// @public +export interface TypeGetStructDefByGuid200Response extends HttpResponse { + // (undocumented) + body: AtlasStructDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetStructDefByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetStructDefByGuidParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetStructDefByName { + get(options?: TypeGetStructDefByNameParameters): StreamableMethod; +} + +// @public +export interface TypeGetStructDefByName200Response extends HttpResponse { + // (undocumented) + body: AtlasStructDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetStructDefByNameDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetStructDefByNameParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetTermTemplateDefByGuid { + get(options?: TypeGetTermTemplateDefByGuidParameters): StreamableMethod; +} + +// @public +export interface TypeGetTermTemplateDefByGuid200Response extends HttpResponse { + // (undocumented) + body: TermTemplateDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetTermTemplateDefByGuidDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetTermTemplateDefByGuidParameters = RequestParameters; + +// @public (undocumented) +export interface TypeGetTermTemplateDefByName { + get(options?: TypeGetTermTemplateDefByNameParameters): StreamableMethod; +} + +// @public +export interface TypeGetTermTemplateDefByName200Response extends HttpResponse { + // (undocumented) + body: TermTemplateDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeGetTermTemplateDefByNameDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeGetTermTemplateDefByNameParameters = RequestParameters; + +// @public (undocumented) +export interface TypeList { + delete(options: TypeBulkDeleteParameters): StreamableMethod; + get(options?: TypeListParameters): StreamableMethod; + post(options: TypeBulkCreateParameters): StreamableMethod; + put(options: TypeBulkUpdateParameters): StreamableMethod; +} + +// @public +export interface TypeList200Response extends HttpResponse { + // (undocumented) + body: AtlasTypesDefOutput; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeListDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export interface TypeListHeaders { + get(options?: TypeListHeadersParameters): StreamableMethod; +} + +// @public +export interface TypeListHeaders200Response extends HttpResponse { + // (undocumented) + body: Array; + // (undocumented) + status: "200"; +} + +// @public (undocumented) +export interface TypeListHeadersDefaultResponse extends HttpResponse { + // (undocumented) + body: AtlasErrorResponseOutput; + // (undocumented) + status: string; +} + +// @public (undocumented) +export type TypeListHeadersParameters = TypeListHeadersQueryParam & RequestParameters; + +// @public (undocumented) +export interface TypeListHeadersQueryParam { + // (undocumented) + queryParameters?: TypeListHeadersQueryParamProperties; +} + +// @public (undocumented) +export interface TypeListHeadersQueryParamProperties { + includeTermTemplate?: boolean; + type?: string; +} + +// @public (undocumented) +export type TypeListParameters = TypeListQueryParam & RequestParameters; + +// @public (undocumented) +export interface TypeListQueryParam { + // (undocumented) + queryParameters?: TypeListQueryParamProperties; +} + +// @public (undocumented) +export interface TypeListQueryParamProperties { + includeTermTemplate?: boolean; + type?: string; +} + +// @public +export interface UpdateTimeFilter extends SearchFilterParent { + kind: "UpdateTimeFilter"; + updateTime: unknown; +} + +// (No @packageDocumentation comment for this package) + +``` diff --git a/sdk/purview/purview-datamap-rest/src/clientDefinitions.ts b/sdk/purview/purview-datamap-rest/src/clientDefinitions.ts new file mode 100644 index 000000000000..6cfd7a0d4cb5 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/clientDefinitions.ts @@ -0,0 +1,1590 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import { + EntityCreateOrUpdateParameters, + EntityListByGuidsParameters, + EntityBulkCreateOrUpdateParameters, + EntityBulkDeleteParameters, + EntityAddClassificationParameters, + EntityGetParameters, + EntityPartialUpdateAttributeByGuidParameters, + EntityDeleteParameters, + EntityGetClassificationParameters, + EntityRemoveClassificationParameters, + EntityGetClassificationsParameters, + EntityAddClassificationsParameters, + EntityUpdateClassificationsParameters, + EntityGetByUniqueAttributesParameters, + EntityPartialUpdateByUniqueAttributesParameters, + EntityDeleteByUniqueAttributeParameters, + EntityRemoveClassificationByUniqueAttributeParameters, + EntityAddClassificationsByUniqueAttributeParameters, + EntityUpdateClassificationsByUniqueAttributeParameters, + EntityBulkSetClassificationsParameters, + EntityListByUniqueAttributesParameters, + EntityGetHeaderParameters, + EntityRemoveBusinessMetadataParameters, + EntityAddOrUpdateBusinessMetadataParameters, + EntityRemoveBusinessMetadataAttributesParameters, + EntityAddOrUpdateBusinessMetadataAttributesParameters, + EntityGetSampleBusinessMetadataTemplateParameters, + EntityImportBusinessMetadataParameters, + EntityRemoveLabelsParameters, + EntitySetLabelsParameters, + EntityAddLabelParameters, + EntityRemoveLabelsByUniqueAttributeParameters, + EntitySetLabelsByUniqueAttributeParameters, + EntityAddLabelsByUniqueAttributeParameters, + EntityMoveEntitiesToCollectionParameters, + GlossaryListParameters, + GlossaryCreateParameters, + GlossaryCreateCategoriesParameters, + GlossaryCreateCategoryParameters, + GlossaryGetCategoryParameters, + GlossaryUpdateCategoryParameters, + GlossaryDeleteCategoryParameters, + GlossaryPartialUpdateCategoryParameters, + GlossaryListRelatedCategoriesParameters, + GlossaryListCategoryTermsParameters, + GlossaryCreateTermParameters, + GlossaryGetTermParameters, + GlossaryUpdateTermParameters, + GlossaryDeleteTermParameters, + GlossaryPartialUpdateTermParameters, + GlossaryCreateTermsParameters, + GlossaryListEntitiesAssignedWithTermParameters, + GlossaryAssignTermToEntitiesParameters, + GlossaryDeleteTermAssignmentFromEntitiesParameters, + GlossaryListRelatedTermsParameters, + GlossaryGetParameters, + GlossaryUpdateParameters, + GlossaryDeleteParameters, + GlossaryListCategoriesParameters, + GlossaryListCategoriesHeadersParameters, + GlossaryGetDetailedParameters, + GlossaryPartialUpdateParameters, + GlossaryListTermsParameters, + GlossaryListTermHeadersParameters, + DiscoveryQueryParameters, + DiscoverySuggestParameters, + DiscoveryAutoCompleteParameters, + LineageGetParameters, + LineageGetNextPageParameters, + LineageGetByUniqueAttributeParameters, + RelationshipCreateParameters, + RelationshipUpdateParameters, + RelationshipGetParameters, + RelationshipDeleteParameters, + TypeGetBusinessMetadataDefByGuidParameters, + TypeGetBusinessMetadataDefByNameParameters, + TypeGetClassificationDefByGuidParameters, + TypeGetClassificationDefByNameParameters, + TypeGetEntityDefByGuidParameters, + TypeGetEntityDefByNameParameters, + TypeGetEnumDefByGuidParameters, + TypeGetEnumDefByNameParameters, + TypeGetRelationshipDefByGuidParameters, + TypeGetRelationshipDefByNameParameters, + TypeGetStructDefByGuidParameters, + TypeGetStructDefByNameParameters, + TypeGetByGuidParameters, + TypeGetByNameParameters, + TypeDeleteParameters, + TypeListParameters, + TypeBulkCreateParameters, + TypeBulkUpdateParameters, + TypeBulkDeleteParameters, + TypeListHeadersParameters, + TypeGetTermTemplateDefByGuidParameters, + TypeGetTermTemplateDefByNameParameters, +} from "./parameters"; +import { + EntityCreateOrUpdate200Response, + EntityCreateOrUpdateDefaultResponse, + EntityListByGuids200Response, + EntityListByGuidsDefaultResponse, + EntityBulkCreateOrUpdate200Response, + EntityBulkCreateOrUpdateDefaultResponse, + EntityBulkDelete200Response, + EntityBulkDeleteDefaultResponse, + EntityAddClassification204Response, + EntityAddClassificationDefaultResponse, + EntityGet200Response, + EntityGetDefaultResponse, + EntityPartialUpdateAttributeByGuid200Response, + EntityPartialUpdateAttributeByGuidDefaultResponse, + EntityDeleteOperation200Response, + EntityDeleteOperationDefaultResponse, + EntityGetClassification200Response, + EntityGetClassificationDefaultResponse, + EntityRemoveClassification204Response, + EntityRemoveClassificationDefaultResponse, + EntityGetClassifications200Response, + EntityGetClassificationsDefaultResponse, + EntityAddClassifications204Response, + EntityAddClassificationsDefaultResponse, + EntityUpdateClassifications204Response, + EntityUpdateClassificationsDefaultResponse, + EntityGetByUniqueAttributes200Response, + EntityGetByUniqueAttributesDefaultResponse, + EntityPartialUpdateByUniqueAttributes200Response, + EntityPartialUpdateByUniqueAttributesDefaultResponse, + EntityDeleteByUniqueAttribute200Response, + EntityDeleteByUniqueAttributeDefaultResponse, + EntityRemoveClassificationByUniqueAttribute204Response, + EntityRemoveClassificationByUniqueAttributeDefaultResponse, + EntityAddClassificationsByUniqueAttribute204Response, + EntityAddClassificationsByUniqueAttributeDefaultResponse, + EntityUpdateClassificationsByUniqueAttribute204Response, + EntityUpdateClassificationsByUniqueAttributeDefaultResponse, + EntityBulkSetClassifications200Response, + EntityBulkSetClassificationsDefaultResponse, + EntityListByUniqueAttributes200Response, + EntityListByUniqueAttributesDefaultResponse, + EntityGetHeader200Response, + EntityGetHeaderDefaultResponse, + EntityRemoveBusinessMetadata204Response, + EntityRemoveBusinessMetadataDefaultResponse, + EntityAddOrUpdateBusinessMetadata204Response, + EntityAddOrUpdateBusinessMetadataDefaultResponse, + EntityRemoveBusinessMetadataAttributes204Response, + EntityRemoveBusinessMetadataAttributesDefaultResponse, + EntityAddOrUpdateBusinessMetadataAttributes204Response, + EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse, + EntityGetSampleBusinessMetadataTemplate200Response, + EntityGetSampleBusinessMetadataTemplateDefaultResponse, + EntityImportBusinessMetadata200Response, + EntityImportBusinessMetadataDefaultResponse, + EntityRemoveLabels204Response, + EntityRemoveLabelsDefaultResponse, + EntitySetLabels204Response, + EntitySetLabelsDefaultResponse, + EntityAddLabel204Response, + EntityAddLabelDefaultResponse, + EntityRemoveLabelsByUniqueAttribute204Response, + EntityRemoveLabelsByUniqueAttributeDefaultResponse, + EntitySetLabelsByUniqueAttribute204Response, + EntitySetLabelsByUniqueAttributeDefaultResponse, + EntityAddLabelsByUniqueAttribute204Response, + EntityAddLabelsByUniqueAttributeDefaultResponse, + EntityMoveEntitiesToCollection200Response, + EntityMoveEntitiesToCollectionDefaultResponse, + GlossaryList200Response, + GlossaryListDefaultResponse, + GlossaryCreate200Response, + GlossaryCreateDefaultResponse, + GlossaryCreateCategories200Response, + GlossaryCreateCategoriesDefaultResponse, + GlossaryCreateCategory200Response, + GlossaryCreateCategoryDefaultResponse, + GlossaryGetCategory200Response, + GlossaryGetCategoryDefaultResponse, + GlossaryUpdateCategory200Response, + GlossaryUpdateCategoryDefaultResponse, + GlossaryDeleteCategory204Response, + GlossaryDeleteCategoryDefaultResponse, + GlossaryPartialUpdateCategory200Response, + GlossaryPartialUpdateCategoryDefaultResponse, + GlossaryListRelatedCategories200Response, + GlossaryListRelatedCategoriesDefaultResponse, + GlossaryListCategoryTerms200Response, + GlossaryListCategoryTermsDefaultResponse, + GlossaryCreateTerm200Response, + GlossaryCreateTermDefaultResponse, + GlossaryGetTerm200Response, + GlossaryGetTermDefaultResponse, + GlossaryUpdateTerm200Response, + GlossaryUpdateTermDefaultResponse, + GlossaryDeleteTerm204Response, + GlossaryDeleteTermDefaultResponse, + GlossaryPartialUpdateTerm200Response, + GlossaryPartialUpdateTermDefaultResponse, + GlossaryCreateTerms200Response, + GlossaryCreateTermsDefaultResponse, + GlossaryListEntitiesAssignedWithTerm200Response, + GlossaryListEntitiesAssignedWithTermDefaultResponse, + GlossaryAssignTermToEntities204Response, + GlossaryAssignTermToEntitiesDefaultResponse, + GlossaryDeleteTermAssignmentFromEntities204Response, + GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse, + GlossaryListRelatedTerms200Response, + GlossaryListRelatedTermsDefaultResponse, + GlossaryGet200Response, + GlossaryGetDefaultResponse, + GlossaryUpdate200Response, + GlossaryUpdateDefaultResponse, + GlossaryDeleteOperation204Response, + GlossaryDeleteOperationDefaultResponse, + GlossaryListCategories200Response, + GlossaryListCategoriesDefaultResponse, + GlossaryListCategoriesHeaders200Response, + GlossaryListCategoriesHeadersDefaultResponse, + GlossaryGetDetailed200Response, + GlossaryGetDetailedDefaultResponse, + GlossaryPartialUpdate200Response, + GlossaryPartialUpdateDefaultResponse, + GlossaryListTerms200Response, + GlossaryListTermsDefaultResponse, + GlossaryListTermHeaders200Response, + GlossaryListTermHeadersDefaultResponse, + DiscoveryQuery200Response, + DiscoveryQueryDefaultResponse, + DiscoverySuggest200Response, + DiscoverySuggestDefaultResponse, + DiscoveryAutoComplete200Response, + DiscoveryAutoCompleteDefaultResponse, + LineageGet200Response, + LineageGetDefaultResponse, + LineageGetNextPage200Response, + LineageGetNextPageDefaultResponse, + LineageGetByUniqueAttribute200Response, + LineageGetByUniqueAttributeDefaultResponse, + RelationshipCreate200Response, + RelationshipCreateDefaultResponse, + RelationshipUpdate200Response, + RelationshipUpdateDefaultResponse, + RelationshipGet200Response, + RelationshipGetDefaultResponse, + RelationshipDeleteOperation204Response, + RelationshipDeleteOperationDefaultResponse, + TypeGetBusinessMetadataDefByGuid200Response, + TypeGetBusinessMetadataDefByGuidDefaultResponse, + TypeGetBusinessMetadataDefByName200Response, + TypeGetBusinessMetadataDefByNameDefaultResponse, + TypeGetClassificationDefByGuid200Response, + TypeGetClassificationDefByGuidDefaultResponse, + TypeGetClassificationDefByName200Response, + TypeGetClassificationDefByNameDefaultResponse, + TypeGetEntityDefByGuid200Response, + TypeGetEntityDefByGuidDefaultResponse, + TypeGetEntityDefByName200Response, + TypeGetEntityDefByNameDefaultResponse, + TypeGetEnumDefByGuid200Response, + TypeGetEnumDefByGuidDefaultResponse, + TypeGetEnumDefByName200Response, + TypeGetEnumDefByNameDefaultResponse, + TypeGetRelationshipDefByGuid200Response, + TypeGetRelationshipDefByGuidDefaultResponse, + TypeGetRelationshipDefByName200Response, + TypeGetRelationshipDefByNameDefaultResponse, + TypeGetStructDefByGuid200Response, + TypeGetStructDefByGuidDefaultResponse, + TypeGetStructDefByName200Response, + TypeGetStructDefByNameDefaultResponse, + TypeGetByGuid200Response, + TypeGetByGuidDefaultResponse, + TypeGetByName200Response, + TypeGetByNameDefaultResponse, + TypeDeleteOperation204Response, + TypeDeleteOperationDefaultResponse, + TypeList200Response, + TypeListDefaultResponse, + TypeBulkCreate200Response, + TypeBulkCreateDefaultResponse, + TypeBulkUpdate200Response, + TypeBulkUpdateDefaultResponse, + TypeBulkDelete204Response, + TypeBulkDeleteDefaultResponse, + TypeListHeaders200Response, + TypeListHeadersDefaultResponse, + TypeGetTermTemplateDefByGuid200Response, + TypeGetTermTemplateDefByGuidDefaultResponse, + TypeGetTermTemplateDefByName200Response, + TypeGetTermTemplateDefByNameDefaultResponse, +} from "./responses"; +import { Client, StreamableMethod } from "@azure-rest/core-client"; + +export interface EntityCreateOrUpdate { + /** + * Create or update an entity. + * Existing entity is matched using its unique guid if + * supplied or by its unique attributes eg: qualifiedName. + * Map and array of + * collections are not well supported. E.g., array>, array>. + * For each contact type, the maximum number of contacts is 20. + */ + post( + options: EntityCreateOrUpdateParameters + ): StreamableMethod< + EntityCreateOrUpdate200Response | EntityCreateOrUpdateDefaultResponse + >; +} + +export interface EntityListByGuids { + /** List entities in bulk identified by its GUIDs. */ + get( + options: EntityListByGuidsParameters + ): StreamableMethod< + EntityListByGuids200Response | EntityListByGuidsDefaultResponse + >; + /** + * Create or update entities in bulk. + * Existing entity is matched using its unique + * guid if supplied or by its unique attributes eg: qualifiedName. + * Map and array + * of collections are not well supported. E.g., array>, + * array>. + * For each contact type, the maximum number of contacts + * is 20. + */ + post( + options: EntityBulkCreateOrUpdateParameters + ): StreamableMethod< + | EntityBulkCreateOrUpdate200Response + | EntityBulkCreateOrUpdateDefaultResponse + >; + /** + * Delete a list of entities in bulk identified by their GUIDs or unique + * attributes. + */ + delete( + options: EntityBulkDeleteParameters + ): StreamableMethod< + EntityBulkDelete200Response | EntityBulkDeleteDefaultResponse + >; +} + +export interface EntityAddClassification { + /** Associate a classification to multiple entities in bulk. */ + post( + options: EntityAddClassificationParameters + ): StreamableMethod< + EntityAddClassification204Response | EntityAddClassificationDefaultResponse + >; +} + +export interface EntityGet { + /** Get complete definition of an entity given its GUID. */ + get( + options?: EntityGetParameters + ): StreamableMethod; + /** + * Update entity partially - create or update entity attribute identified by its + * GUID. + * Supports only primitive attribute type and entity references. + * It does not support updating complex types like arrays, and maps. + * Null updates are not possible. + */ + put( + options: EntityPartialUpdateAttributeByGuidParameters + ): StreamableMethod< + | EntityPartialUpdateAttributeByGuid200Response + | EntityPartialUpdateAttributeByGuidDefaultResponse + >; + /** Delete an entity identified by its GUID. */ + delete( + options?: EntityDeleteParameters + ): StreamableMethod< + EntityDeleteOperation200Response | EntityDeleteOperationDefaultResponse + >; +} + +export interface EntityGetClassification { + /** Get classification for a given entity represented by a GUID. */ + get( + options?: EntityGetClassificationParameters + ): StreamableMethod< + EntityGetClassification200Response | EntityGetClassificationDefaultResponse + >; + /** Delete a given classification from an existing entity represented by a GUID. */ + delete( + options?: EntityRemoveClassificationParameters + ): StreamableMethod< + | EntityRemoveClassification204Response + | EntityRemoveClassificationDefaultResponse + >; +} + +export interface EntityGetClassifications { + /** List classifications for a given entity represented by a GUID. */ + get( + options?: EntityGetClassificationsParameters + ): StreamableMethod< + | EntityGetClassifications200Response + | EntityGetClassificationsDefaultResponse + >; + /** Add classifications to an existing entity represented by a GUID. */ + post( + options: EntityAddClassificationsParameters + ): StreamableMethod< + | EntityAddClassifications204Response + | EntityAddClassificationsDefaultResponse + >; + /** Update classifications to an existing entity represented by a guid. */ + put( + options: EntityUpdateClassificationsParameters + ): StreamableMethod< + | EntityUpdateClassifications204Response + | EntityUpdateClassificationsDefaultResponse + >; +} + +export interface EntityGetByUniqueAttributes { + /** + * Get complete definition of an entity given its type and unique attribute. + * + * In + * addition to the typeName path parameter, attribute key-value pair(s) can be + * provided in the following format: + * attr:\=. + * + * NOTE: The + * attrName and attrValue should be unique across entities, eg. + * qualifiedName. + * + * The REST request would look something like this: + * GET + * /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue. + */ + get( + options?: EntityGetByUniqueAttributesParameters + ): StreamableMethod< + | EntityGetByUniqueAttributes200Response + | EntityGetByUniqueAttributesDefaultResponse + >; + /** + * Update entity partially - Allow a subset of attributes to be updated on an + * entity which is identified by its type and unique attribute eg: + * Referenceable.qualifiedName. Null updates are not possible. + * + * In addition to the + * typeName path parameter, attribute key-value pair(s) can be provided in the + * following format: + * + * attr:=. + * NOTE: The attrName and + * attrValue should be unique across entities, eg. qualifiedName. + * + * The REST + * request would look something like this: + * PUT + * /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue. + */ + put( + options: EntityPartialUpdateByUniqueAttributesParameters + ): StreamableMethod< + | EntityPartialUpdateByUniqueAttributes200Response + | EntityPartialUpdateByUniqueAttributesDefaultResponse + >; + /** + * Delete an entity identified by its type and unique attributes. + * In addition to + * the typeName path parameter, attribute key-value pair(s) can be provided in the + * following format: + * attr:\=\. + * NOTE: The attrName and + * attrValue should be unique across entities, eg. qualifiedName. + * + * The REST + * request would look something like this: + * DELETE + * /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue. + */ + delete( + options?: EntityDeleteByUniqueAttributeParameters + ): StreamableMethod< + | EntityDeleteByUniqueAttribute200Response + | EntityDeleteByUniqueAttributeDefaultResponse + >; +} + +export interface EntityRemoveClassificationByUniqueAttribute { + /** + * Delete a given classification from an entity identified by its type and unique + * attributes. + */ + delete( + options?: EntityRemoveClassificationByUniqueAttributeParameters + ): StreamableMethod< + | EntityRemoveClassificationByUniqueAttribute204Response + | EntityRemoveClassificationByUniqueAttributeDefaultResponse + >; +} + +export interface EntityAddClassificationsByUniqueAttribute { + /** Add classification to the entity identified by its type and unique attributes. */ + post( + options: EntityAddClassificationsByUniqueAttributeParameters + ): StreamableMethod< + | EntityAddClassificationsByUniqueAttribute204Response + | EntityAddClassificationsByUniqueAttributeDefaultResponse + >; + /** Update classification on an entity identified by its type and unique attributes. */ + put( + options: EntityUpdateClassificationsByUniqueAttributeParameters + ): StreamableMethod< + | EntityUpdateClassificationsByUniqueAttribute204Response + | EntityUpdateClassificationsByUniqueAttributeDefaultResponse + >; +} + +export interface EntityBulkSetClassifications { + /** Set classifications on entities in bulk. */ + post( + options: EntityBulkSetClassificationsParameters + ): StreamableMethod< + | EntityBulkSetClassifications200Response + | EntityBulkSetClassificationsDefaultResponse + >; +} + +export interface EntityListByUniqueAttributes { + /** + * Bulk API to retrieve list of entities identified by its unique attributes. + * In + * addition to the typeName path parameter, attribute key-value pair(s) can be + * provided in the following + * format + * + * typeName=\&attr_1:\=\&attr_2:\=\&attr_3:\=\ + * + * NOTE: + * The attrName should be an unique attribute for the given entity-type. + * The REST + * request would look something like this + * + * GET + * /v2/entity/bulk/uniqueAttribute/type/hive_db?attr_1:qualifiedName=db1@cl1&attr_2:qualifiedName=db2@cl1 + * + * Note: + * at least one unique attribute must be provided. + */ + get( + options?: EntityListByUniqueAttributesParameters + ): StreamableMethod< + | EntityListByUniqueAttributes200Response + | EntityListByUniqueAttributesDefaultResponse + >; +} + +export interface EntityGetHeader { + /** Get entity header given its GUID. */ + get( + options?: EntityGetHeaderParameters + ): StreamableMethod< + EntityGetHeader200Response | EntityGetHeaderDefaultResponse + >; +} + +export interface EntityRemoveBusinessMetadata { + /** Remove business metadata from an entity. */ + delete( + options: EntityRemoveBusinessMetadataParameters + ): StreamableMethod< + | EntityRemoveBusinessMetadata204Response + | EntityRemoveBusinessMetadataDefaultResponse + >; + /** Add business metadata to an entity. */ + post( + options: EntityAddOrUpdateBusinessMetadataParameters + ): StreamableMethod< + | EntityAddOrUpdateBusinessMetadata204Response + | EntityAddOrUpdateBusinessMetadataDefaultResponse + >; +} + +export interface EntityRemoveBusinessMetadataAttributes { + /** Delete business metadata attributes from an entity. */ + delete( + options: EntityRemoveBusinessMetadataAttributesParameters + ): StreamableMethod< + | EntityRemoveBusinessMetadataAttributes204Response + | EntityRemoveBusinessMetadataAttributesDefaultResponse + >; + /** Add or update business metadata attributes. */ + post( + options: EntityAddOrUpdateBusinessMetadataAttributesParameters + ): StreamableMethod< + | EntityAddOrUpdateBusinessMetadataAttributes204Response + | EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse + >; +} + +export interface EntityGetSampleBusinessMetadataTemplate { + /** Get the sample Template for uploading/creating bulk BusinessMetaData */ + get( + options?: EntityGetSampleBusinessMetadataTemplateParameters + ): StreamableMethod< + | EntityGetSampleBusinessMetadataTemplate200Response + | EntityGetSampleBusinessMetadataTemplateDefaultResponse + >; +} + +export interface EntityImportBusinessMetadata { + /** Upload the file for creating Business Metadata in BULK */ + post( + options: EntityImportBusinessMetadataParameters + ): StreamableMethod< + | EntityImportBusinessMetadata200Response + | EntityImportBusinessMetadataDefaultResponse + >; +} + +export interface EntityRemoveLabels { + /** Delete given labels to a given entity. */ + delete( + options: EntityRemoveLabelsParameters + ): StreamableMethod< + EntityRemoveLabels204Response | EntityRemoveLabelsDefaultResponse + >; + /** Set labels to a given entity. */ + post( + options: EntitySetLabelsParameters + ): StreamableMethod< + EntitySetLabels204Response | EntitySetLabelsDefaultResponse + >; + /** Add given labels to a given entity. */ + put( + options: EntityAddLabelParameters + ): StreamableMethod< + EntityAddLabel204Response | EntityAddLabelDefaultResponse + >; +} + +export interface EntityRemoveLabelsByUniqueAttribute { + /** + * Delete given labels to a given entity identified by its type and unique + * attribute. + * + * If labels is null/empty, no labels will be removed. + * + * If any labels + * in labels set are non-existing labels, they will be ignored, only existing + * labels will be removed. In addition to the typeName path parameter, attribute + * key-value pair(s) can be provided in the following format: + * attr:=. NOTE: The attrName and attrValue should be unique + * across entities, eg. qualifiedName. The REST request would look something like + * this: DELETE + * /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue. + */ + delete( + options: EntityRemoveLabelsByUniqueAttributeParameters + ): StreamableMethod< + | EntityRemoveLabelsByUniqueAttribute204Response + | EntityRemoveLabelsByUniqueAttributeDefaultResponse + >; + /** + * Set labels to a given entity identified by its type and unique attributes. + * + * If + * labels is null/empty, existing labels will all be removed. + * + * In addition to the + * typeName path parameter, attribute key-value pair(s) can be provided in the + * following format: attr:=. + * + * NOTE: The attrName and + * attrValue should be unique across entities, eg. qualifiedName. + * + * The REST + * request would look something like this: POST + * /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue. + */ + post( + options: EntitySetLabelsByUniqueAttributeParameters + ): StreamableMethod< + | EntitySetLabelsByUniqueAttribute204Response + | EntitySetLabelsByUniqueAttributeDefaultResponse + >; + /** + * Add given labels to a given entity identified by its type and unique + * attributes. + * + * If labels is null/empty, no labels will be added. + * + * In addition to + * the typeName path parameter, attribute key-value pair(s) can be provided in the + * following format: attr:=. + * + * NOTE: The attrName and + * attrValue should be unique across entities, eg. qualifiedName. + * + * The REST + * request would look something like this: PUT + * /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue. + */ + put( + options: EntityAddLabelsByUniqueAttributeParameters + ): StreamableMethod< + | EntityAddLabelsByUniqueAttribute204Response + | EntityAddLabelsByUniqueAttributeDefaultResponse + >; +} + +export interface EntityMoveEntitiesToCollection { + /** Move existing entities to the target collection. */ + post( + options: EntityMoveEntitiesToCollectionParameters + ): StreamableMethod< + | EntityMoveEntitiesToCollection200Response + | EntityMoveEntitiesToCollectionDefaultResponse + >; +} + +export interface GlossaryList { + /** + * Get all glossaries. Recommend using limit/offset to get pagination result. + * Recommend using 'ignoreTermsAndCategories=true' and fetch terms/categories + * separately using + * + * 'GET /datamap/api/atlas/v2/glossary/{glossaryGuid}/terms' + * and + * + * 'GET '/datamap/api/atlas/v2/glossary/{glossaryGuid}/categories'. + */ + get( + options?: GlossaryListParameters + ): StreamableMethod; + /** Create a glossary. */ + post( + options: GlossaryCreateParameters + ): StreamableMethod< + GlossaryCreate200Response | GlossaryCreateDefaultResponse + >; +} + +export interface GlossaryCreateCategories { + /** Create glossary category in bulk. */ + post( + options: GlossaryCreateCategoriesParameters + ): StreamableMethod< + | GlossaryCreateCategories200Response + | GlossaryCreateCategoriesDefaultResponse + >; +} + +export interface GlossaryCreateCategory { + /** Create a glossary category. */ + post( + options: GlossaryCreateCategoryParameters + ): StreamableMethod< + GlossaryCreateCategory200Response | GlossaryCreateCategoryDefaultResponse + >; +} + +export interface GlossaryGetCategory { + /** Get specific glossary category by its GUID. */ + get( + options?: GlossaryGetCategoryParameters + ): StreamableMethod< + GlossaryGetCategory200Response | GlossaryGetCategoryDefaultResponse + >; + /** Update the given glossary category by its GUID. */ + put( + options: GlossaryUpdateCategoryParameters + ): StreamableMethod< + GlossaryUpdateCategory200Response | GlossaryUpdateCategoryDefaultResponse + >; + /** Delete a glossary category. */ + delete( + options?: GlossaryDeleteCategoryParameters + ): StreamableMethod< + GlossaryDeleteCategory204Response | GlossaryDeleteCategoryDefaultResponse + >; +} + +export interface GlossaryPartialUpdateCategory { + /** + * Update the glossary category partially. So far we only supports partial + * updating shortDescription and longDescription for category. + */ + put( + options: GlossaryPartialUpdateCategoryParameters + ): StreamableMethod< + | GlossaryPartialUpdateCategory200Response + | GlossaryPartialUpdateCategoryDefaultResponse + >; +} + +export interface GlossaryListRelatedCategories { + /** + * Get all related categories (parent and children). Limit, offset, and sort + * parameters are currently not being enabled and won't work even they are passed. + */ + get( + options?: GlossaryListRelatedCategoriesParameters + ): StreamableMethod< + | GlossaryListRelatedCategories200Response + | GlossaryListRelatedCategoriesDefaultResponse + >; +} + +export interface GlossaryListCategoryTerms { + /** Get all terms associated with the specific category. */ + get( + options?: GlossaryListCategoryTermsParameters + ): StreamableMethod< + | GlossaryListCategoryTerms200Response + | GlossaryListCategoryTermsDefaultResponse + >; +} + +export interface GlossaryCreateTerm { + /** Create a glossary term. */ + post( + options: GlossaryCreateTermParameters + ): StreamableMethod< + GlossaryCreateTerm200Response | GlossaryCreateTermDefaultResponse + >; +} + +export interface GlossaryGetTerm { + /** Get a specific glossary term by its GUID. */ + get( + options?: GlossaryGetTermParameters + ): StreamableMethod< + GlossaryGetTerm200Response | GlossaryGetTermDefaultResponse + >; + /** Update the given glossary term by its GUID. */ + put( + options: GlossaryUpdateTermParameters + ): StreamableMethod< + GlossaryUpdateTerm200Response | GlossaryUpdateTermDefaultResponse + >; + /** Delete a glossary term. */ + delete( + options?: GlossaryDeleteTermParameters + ): StreamableMethod< + GlossaryDeleteTerm204Response | GlossaryDeleteTermDefaultResponse + >; +} + +export interface GlossaryPartialUpdateTerm { + /** + * Update the glossary term partially. So far we only supports partial updating + * shortDescription, longDescription, abbreviation, usage and status for term. + */ + put( + options: GlossaryPartialUpdateTermParameters + ): StreamableMethod< + | GlossaryPartialUpdateTerm200Response + | GlossaryPartialUpdateTermDefaultResponse + >; +} + +export interface GlossaryCreateTerms { + /** Create glossary terms in bulk. */ + post( + options: GlossaryCreateTermsParameters + ): StreamableMethod< + GlossaryCreateTerms200Response | GlossaryCreateTermsDefaultResponse + >; +} + +export interface GlossaryListEntitiesAssignedWithTerm { + /** + * List all related objects assigned with the specified term. Recommend using + * limit/offset to get pagination result. + */ + get( + options?: GlossaryListEntitiesAssignedWithTermParameters + ): StreamableMethod< + | GlossaryListEntitiesAssignedWithTerm200Response + | GlossaryListEntitiesAssignedWithTermDefaultResponse + >; + /** + * Assign the given term to the provided list of related objects. Recommend using + * small batches with multiple API calls. + * + * [Entities Create Or Update + * operation](https://learn.microsoft.com/en-us/rest/api/purview/datamapdataplane/entity/bulk-create-or-update?tabs=HTTP) + * is an alternative to assign a term to multiple entities. + */ + post( + options: GlossaryAssignTermToEntitiesParameters + ): StreamableMethod< + | GlossaryAssignTermToEntities204Response + | GlossaryAssignTermToEntitiesDefaultResponse + >; + /** Delete the term assignment for the given list of related objects. */ + delete( + options: GlossaryDeleteTermAssignmentFromEntitiesParameters + ): StreamableMethod< + | GlossaryDeleteTermAssignmentFromEntities204Response + | GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse + >; +} + +export interface GlossaryListRelatedTerms { + /** + * Get all related terms for a specific term by its GUID. Limit, offset, and sort + * parameters are currently not being enabled and won't work even they are passed. + */ + get( + options?: GlossaryListRelatedTermsParameters + ): StreamableMethod< + | GlossaryListRelatedTerms200Response + | GlossaryListRelatedTermsDefaultResponse + >; +} + +export interface GlossaryGet { + /** Get a specific Glossary by its GUID. */ + get( + options?: GlossaryGetParameters + ): StreamableMethod; + /** Update the given glossary. */ + put( + options: GlossaryUpdateParameters + ): StreamableMethod< + GlossaryUpdate200Response | GlossaryUpdateDefaultResponse + >; + /** + * Delete a glossary. Will delete underlying terms/categories together. Recommend + * separate delete terms and categories. + */ + delete( + options?: GlossaryDeleteParameters + ): StreamableMethod< + GlossaryDeleteOperation204Response | GlossaryDeleteOperationDefaultResponse + >; +} + +export interface GlossaryListCategories { + /** + * Get the categories belonging to a specific glossary. Recommend using + * limit/offset to get pagination result. + */ + get( + options?: GlossaryListCategoriesParameters + ): StreamableMethod< + GlossaryListCategories200Response | GlossaryListCategoriesDefaultResponse + >; +} + +export interface GlossaryListCategoriesHeaders { + /** + * Get the category headers belonging to a specific glossary. Recommend using + * limit/offset to get pagination result. + */ + get( + options?: GlossaryListCategoriesHeadersParameters + ): StreamableMethod< + | GlossaryListCategoriesHeaders200Response + | GlossaryListCategoriesHeadersDefaultResponse + >; +} + +export interface GlossaryGetDetailed { + /** + * Get a specific glossary with detailed information. This API is not + * recommend. + * + * Recommend to fetch terms/categories details separately using + * + * GET /datamap/api/atlas/v2/glossary/{glossaryGuid}/terms and + * + * GET /datamap/api/atlas/v2/glossary/{glossaryGuid}/categories. + */ + get( + options?: GlossaryGetDetailedParameters + ): StreamableMethod< + GlossaryGetDetailed200Response | GlossaryGetDetailedDefaultResponse + >; +} + +export interface GlossaryPartialUpdate { + /** + * Update the glossary partially. Some properties such as qualifiedName are not + * allowed to be updated. + * + * So far we only supports partial updating + * shortDescription, longDescription, language and usage for glossary. + * + * Recommend + * using 'ignoreTermsAndCategories=true' to reduce response body size. + */ + put( + options: GlossaryPartialUpdateParameters + ): StreamableMethod< + GlossaryPartialUpdate200Response | GlossaryPartialUpdateDefaultResponse + >; +} + +export interface GlossaryListTerms { + /** + * Get terms belonging to a specific glossary. Recommend using limit/offset to get + * pagination result. + */ + get( + options?: GlossaryListTermsParameters + ): StreamableMethod< + GlossaryListTerms200Response | GlossaryListTermsDefaultResponse + >; +} + +export interface GlossaryListTermHeaders { + /** + * Get term headers belonging to a specific glossary. Recommend using limit/offset + * to get pagination result. + */ + get( + options?: GlossaryListTermHeadersParameters + ): StreamableMethod< + GlossaryListTermHeaders200Response | GlossaryListTermHeadersDefaultResponse + >; +} + +export interface DiscoveryQuery { + /** Get data using search. */ + post( + options: DiscoveryQueryParameters + ): StreamableMethod< + DiscoveryQuery200Response | DiscoveryQueryDefaultResponse + >; +} + +export interface DiscoverySuggest { + /** Get search suggestions by query criteria. */ + post( + options: DiscoverySuggestParameters + ): StreamableMethod< + DiscoverySuggest200Response | DiscoverySuggestDefaultResponse + >; +} + +export interface DiscoveryAutoComplete { + /** Get auto complete options. */ + post( + options: DiscoveryAutoCompleteParameters + ): StreamableMethod< + DiscoveryAutoComplete200Response | DiscoveryAutoCompleteDefaultResponse + >; +} + +export interface LineageGet { + /** Get lineage info of the entity specified by GUID. */ + get( + options: LineageGetParameters + ): StreamableMethod; +} + +export interface LineageGetNextPage { + /** Return immediate next page lineage info about entity with pagination */ + get( + options: LineageGetNextPageParameters + ): StreamableMethod< + LineageGetNextPage200Response | LineageGetNextPageDefaultResponse + >; +} + +export interface LineageGetByUniqueAttribute { + /** + * Return lineage info about entity. + * + * In addition to the typeName path parameter, + * attribute key-value pair(s) can be provided in the following + * format + * + * attr:[attrName]=[attrValue] + * + * NOTE: The attrName and attrValue should be + * unique across entities, eg. qualifiedName. + * + * The REST request would look + * something like this: + * + * GET + * /v2/lineage/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue. + */ + get( + options: LineageGetByUniqueAttributeParameters + ): StreamableMethod< + | LineageGetByUniqueAttribute200Response + | LineageGetByUniqueAttributeDefaultResponse + >; +} + +export interface RelationshipCreate { + /** Create a new relationship between entities. */ + post( + options: RelationshipCreateParameters + ): StreamableMethod< + RelationshipCreate200Response | RelationshipCreateDefaultResponse + >; + /** Update an existing relationship between entities. */ + put( + options: RelationshipUpdateParameters + ): StreamableMethod< + RelationshipUpdate200Response | RelationshipUpdateDefaultResponse + >; +} + +export interface RelationshipGet { + /** Get relationship information between entities by its GUID. */ + get( + options?: RelationshipGetParameters + ): StreamableMethod< + RelationshipGet200Response | RelationshipGetDefaultResponse + >; + /** Delete a relationship between entities by its GUID. */ + delete( + options?: RelationshipDeleteParameters + ): StreamableMethod< + | RelationshipDeleteOperation204Response + | RelationshipDeleteOperationDefaultResponse + >; +} + +export interface TypeGetBusinessMetadataDefByGuid { + /** Get the businessMetadata definition for the given guid. */ + get( + options?: TypeGetBusinessMetadataDefByGuidParameters + ): StreamableMethod< + | TypeGetBusinessMetadataDefByGuid200Response + | TypeGetBusinessMetadataDefByGuidDefaultResponse + >; +} + +export interface TypeGetBusinessMetadataDefByName { + /** Get the businessMetadata definition by it's name (unique). */ + get( + options?: TypeGetBusinessMetadataDefByNameParameters + ): StreamableMethod< + | TypeGetBusinessMetadataDefByName200Response + | TypeGetBusinessMetadataDefByNameDefaultResponse + >; +} + +export interface TypeGetClassificationDefByGuid { + /** Get the classification definition for the given GUID. */ + get( + options?: TypeGetClassificationDefByGuidParameters + ): StreamableMethod< + | TypeGetClassificationDefByGuid200Response + | TypeGetClassificationDefByGuidDefaultResponse + >; +} + +export interface TypeGetClassificationDefByName { + /** Get the classification definition by its name (unique). */ + get( + options?: TypeGetClassificationDefByNameParameters + ): StreamableMethod< + | TypeGetClassificationDefByName200Response + | TypeGetClassificationDefByNameDefaultResponse + >; +} + +export interface TypeGetEntityDefByGuid { + /** Get the Entity definition for the given GUID. */ + get( + options?: TypeGetEntityDefByGuidParameters + ): StreamableMethod< + TypeGetEntityDefByGuid200Response | TypeGetEntityDefByGuidDefaultResponse + >; +} + +export interface TypeGetEntityDefByName { + /** Get the entity definition by its name (unique). */ + get( + options?: TypeGetEntityDefByNameParameters + ): StreamableMethod< + TypeGetEntityDefByName200Response | TypeGetEntityDefByNameDefaultResponse + >; +} + +export interface TypeGetEnumDefByGuid { + /** Get the enum definition for the given GUID. */ + get( + options?: TypeGetEnumDefByGuidParameters + ): StreamableMethod< + TypeGetEnumDefByGuid200Response | TypeGetEnumDefByGuidDefaultResponse + >; +} + +export interface TypeGetEnumDefByName { + /** Get the enum definition by its name (unique). */ + get( + options?: TypeGetEnumDefByNameParameters + ): StreamableMethod< + TypeGetEnumDefByName200Response | TypeGetEnumDefByNameDefaultResponse + >; +} + +export interface TypeGetRelationshipDefByGuid { + /** Get the relationship definition for the given GUID. */ + get( + options?: TypeGetRelationshipDefByGuidParameters + ): StreamableMethod< + | TypeGetRelationshipDefByGuid200Response + | TypeGetRelationshipDefByGuidDefaultResponse + >; +} + +export interface TypeGetRelationshipDefByName { + /** Get the relationship definition by its name (unique). */ + get( + options?: TypeGetRelationshipDefByNameParameters + ): StreamableMethod< + | TypeGetRelationshipDefByName200Response + | TypeGetRelationshipDefByNameDefaultResponse + >; +} + +export interface TypeGetStructDefByGuid { + /** Get the struct definition for the given GUID. */ + get( + options?: TypeGetStructDefByGuidParameters + ): StreamableMethod< + TypeGetStructDefByGuid200Response | TypeGetStructDefByGuidDefaultResponse + >; +} + +export interface TypeGetStructDefByName { + /** Get the struct definition by its name (unique). */ + get( + options?: TypeGetStructDefByNameParameters + ): StreamableMethod< + TypeGetStructDefByName200Response | TypeGetStructDefByNameDefaultResponse + >; +} + +export interface TypeGetByGuid { + /** Get the type definition for the given GUID. */ + get( + options?: TypeGetByGuidParameters + ): StreamableMethod; +} + +export interface TypeGetByName { + /** Get the type definition by its name (unique). */ + get( + options?: TypeGetByNameParameters + ): StreamableMethod; + /** Delete API for type identified by its name. */ + delete( + options?: TypeDeleteParameters + ): StreamableMethod< + TypeDeleteOperation204Response | TypeDeleteOperationDefaultResponse + >; +} + +export interface TypeList { + /** List all type definitions in bulk. */ + get( + options?: TypeListParameters + ): StreamableMethod; + /** + * Create all atlas type definitions in bulk, only new definitions will be + * created. + * Any changes to the existing definitions will be discarded. + */ + post( + options: TypeBulkCreateParameters + ): StreamableMethod< + TypeBulkCreate200Response | TypeBulkCreateDefaultResponse + >; + /** + * Update all types in bulk, changes detected in the type definitions would be + * persisted. + */ + put( + options: TypeBulkUpdateParameters + ): StreamableMethod< + TypeBulkUpdate200Response | TypeBulkUpdateDefaultResponse + >; + /** Delete API for all types in bulk. */ + delete( + options: TypeBulkDeleteParameters + ): StreamableMethod< + TypeBulkDelete204Response | TypeBulkDeleteDefaultResponse + >; +} + +export interface TypeListHeaders { + /** List all type definitions returned as a list of minimal information header. */ + get( + options?: TypeListHeadersParameters + ): StreamableMethod< + TypeListHeaders200Response | TypeListHeadersDefaultResponse + >; +} + +export interface TypeGetTermTemplateDefByGuid { + /** Get the term template definition for the given GUID. */ + get( + options?: TypeGetTermTemplateDefByGuidParameters + ): StreamableMethod< + | TypeGetTermTemplateDefByGuid200Response + | TypeGetTermTemplateDefByGuidDefaultResponse + >; +} + +export interface TypeGetTermTemplateDefByName { + /** Get the term template definition by its name (unique). */ + get( + options?: TypeGetTermTemplateDefByNameParameters + ): StreamableMethod< + | TypeGetTermTemplateDefByName200Response + | TypeGetTermTemplateDefByNameDefaultResponse + >; +} + +export interface Routes { + /** Resource for '/atlas/v2/entity' has methods for the following verbs: post */ + (path: "/atlas/v2/entity"): EntityCreateOrUpdate; + /** Resource for '/atlas/v2/entity/bulk' has methods for the following verbs: get, post, delete */ + (path: "/atlas/v2/entity/bulk"): EntityListByGuids; + /** Resource for '/atlas/v2/entity/bulk/classification' has methods for the following verbs: post */ + (path: "/atlas/v2/entity/bulk/classification"): EntityAddClassification; + /** Resource for '/atlas/v2/entity/guid/\{guid\}' has methods for the following verbs: get, put, delete */ + (path: "/atlas/v2/entity/guid/{guid}", guid: string): EntityGet; + /** Resource for '/atlas/v2/entity/guid/\{guid\}/classification/\{classificationName\}' has methods for the following verbs: get, delete */ + ( + path: "/atlas/v2/entity/guid/{guid}/classification/{classificationName}", + guid: string, + classificationName: string + ): EntityGetClassification; + /** Resource for '/atlas/v2/entity/guid/\{guid\}/classifications' has methods for the following verbs: get, post, put */ + ( + path: "/atlas/v2/entity/guid/{guid}/classifications", + guid: string + ): EntityGetClassifications; + /** Resource for '/atlas/v2/entity/uniqueAttribute/type/\{typeName\}' has methods for the following verbs: get, put, delete */ + ( + path: "/atlas/v2/entity/uniqueAttribute/type/{typeName}", + typeName: string + ): EntityGetByUniqueAttributes; + /** Resource for '/atlas/v2/entity/uniqueAttribute/type/\{typeName\}/classification/\{classificationName\}' has methods for the following verbs: delete */ + ( + path: "/atlas/v2/entity/uniqueAttribute/type/{typeName}/classification/{classificationName}", + typeName: string, + classificationName: string + ): EntityRemoveClassificationByUniqueAttribute; + /** Resource for '/atlas/v2/entity/uniqueAttribute/type/\{typeName\}/classifications' has methods for the following verbs: post, put */ + ( + path: "/atlas/v2/entity/uniqueAttribute/type/{typeName}/classifications", + typeName: string + ): EntityAddClassificationsByUniqueAttribute; + /** Resource for '/atlas/v2/entity/bulk/setClassifications' has methods for the following verbs: post */ + ( + path: "/atlas/v2/entity/bulk/setClassifications" + ): EntityBulkSetClassifications; + /** Resource for '/atlas/v2/entity/bulk/uniqueAttribute/type/\{typeName\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/entity/bulk/uniqueAttribute/type/{typeName}", + typeName: string + ): EntityListByUniqueAttributes; + /** Resource for '/atlas/v2/entity/guid/\{guid\}/header' has methods for the following verbs: get */ + (path: "/atlas/v2/entity/guid/{guid}/header", guid: string): EntityGetHeader; + /** Resource for '/atlas/v2/entity/guid/\{guid\}/businessmetadata' has methods for the following verbs: delete, post */ + ( + path: "/atlas/v2/entity/guid/{guid}/businessmetadata", + guid: string + ): EntityRemoveBusinessMetadata; + /** Resource for '/atlas/v2/entity/guid/\{guid\}/businessmetadata/\{bmName\}' has methods for the following verbs: delete, post */ + ( + path: "/atlas/v2/entity/guid/{guid}/businessmetadata/{bmName}", + bmName: string, + guid: string + ): EntityRemoveBusinessMetadataAttributes; + /** Resource for '/atlas/v2/entity/businessmetadata/import/template' has methods for the following verbs: get */ + ( + path: "/atlas/v2/entity/businessmetadata/import/template" + ): EntityGetSampleBusinessMetadataTemplate; + /** Resource for '/atlas/v2/entity/businessmetadata/import' has methods for the following verbs: post */ + ( + path: "/atlas/v2/entity/businessmetadata/import" + ): EntityImportBusinessMetadata; + /** Resource for '/atlas/v2/entity/guid/\{guid\}/labels' has methods for the following verbs: delete, post, put */ + ( + path: "/atlas/v2/entity/guid/{guid}/labels", + guid: string + ): EntityRemoveLabels; + /** Resource for '/atlas/v2/entity/uniqueAttribute/type/\{typeName\}/labels' has methods for the following verbs: delete, post, put */ + ( + path: "/atlas/v2/entity/uniqueAttribute/type/{typeName}/labels", + typeName: string + ): EntityRemoveLabelsByUniqueAttribute; + /** Resource for '/entity/moveTo' has methods for the following verbs: post */ + (path: "/entity/moveTo"): EntityMoveEntitiesToCollection; + /** Resource for '/atlas/v2/glossary' has methods for the following verbs: get, post */ + (path: "/atlas/v2/glossary"): GlossaryList; + /** Resource for '/atlas/v2/glossary/categories' has methods for the following verbs: post */ + (path: "/atlas/v2/glossary/categories"): GlossaryCreateCategories; + /** Resource for '/atlas/v2/glossary/category' has methods for the following verbs: post */ + (path: "/atlas/v2/glossary/category"): GlossaryCreateCategory; + /** Resource for '/atlas/v2/glossary/category/\{categoryGuid\}' has methods for the following verbs: get, put, delete */ + ( + path: "/atlas/v2/glossary/category/{categoryGuid}", + categoryGuid: string + ): GlossaryGetCategory; + /** Resource for '/atlas/v2/glossary/category/\{categoryGuid\}/partial' has methods for the following verbs: put */ + ( + path: "/atlas/v2/glossary/category/{categoryGuid}/partial", + categoryGuid: string + ): GlossaryPartialUpdateCategory; + /** Resource for '/atlas/v2/glossary/category/\{categoryGuid\}/related' has methods for the following verbs: get */ + ( + path: "/atlas/v2/glossary/category/{categoryGuid}/related", + categoryGuid: string + ): GlossaryListRelatedCategories; + /** Resource for '/atlas/v2/glossary/category/\{categoryGuid\}/terms' has methods for the following verbs: get */ + ( + path: "/atlas/v2/glossary/category/{categoryGuid}/terms", + categoryGuid: string + ): GlossaryListCategoryTerms; + /** Resource for '/atlas/v2/glossary/term' has methods for the following verbs: post */ + (path: "/atlas/v2/glossary/term"): GlossaryCreateTerm; + /** Resource for '/atlas/v2/glossary/term/\{termGuid\}' has methods for the following verbs: get, put, delete */ + ( + path: "/atlas/v2/glossary/term/{termGuid}", + termGuid: string + ): GlossaryGetTerm; + /** Resource for '/atlas/v2/glossary/term/\{termGuid\}/partial' has methods for the following verbs: put */ + ( + path: "/atlas/v2/glossary/term/{termGuid}/partial", + termGuid: string + ): GlossaryPartialUpdateTerm; + /** Resource for '/atlas/v2/glossary/terms' has methods for the following verbs: post */ + (path: "/atlas/v2/glossary/terms"): GlossaryCreateTerms; + /** Resource for '/atlas/v2/glossary/terms/\{termGuid\}/assignedEntities' has methods for the following verbs: get, post, delete */ + ( + path: "/atlas/v2/glossary/terms/{termGuid}/assignedEntities", + termGuid: string + ): GlossaryListEntitiesAssignedWithTerm; + /** Resource for '/atlas/v2/glossary/terms/\{termGuid\}/related' has methods for the following verbs: get */ + ( + path: "/atlas/v2/glossary/terms/{termGuid}/related", + termGuid: string + ): GlossaryListRelatedTerms; + /** Resource for '/atlas/v2/glossary/\{glossaryGuid\}' has methods for the following verbs: get, put, delete */ + ( + path: "/atlas/v2/glossary/{glossaryGuid}", + glossaryGuid: string + ): GlossaryGet; + /** Resource for '/atlas/v2/glossary/\{glossaryGuid\}/categories' has methods for the following verbs: get */ + ( + path: "/atlas/v2/glossary/{glossaryGuid}/categories", + glossaryGuid: string + ): GlossaryListCategories; + /** Resource for '/atlas/v2/glossary/\{glossaryGuid\}/categories/headers' has methods for the following verbs: get */ + ( + path: "/atlas/v2/glossary/{glossaryGuid}/categories/headers", + glossaryGuid: string + ): GlossaryListCategoriesHeaders; + /** Resource for '/atlas/v2/glossary/\{glossaryGuid\}/detailed' has methods for the following verbs: get */ + ( + path: "/atlas/v2/glossary/{glossaryGuid}/detailed", + glossaryGuid: string + ): GlossaryGetDetailed; + /** Resource for '/atlas/v2/glossary/\{glossaryGuid\}/partial' has methods for the following verbs: put */ + ( + path: "/atlas/v2/glossary/{glossaryGuid}/partial", + glossaryGuid: string + ): GlossaryPartialUpdate; + /** Resource for '/atlas/v2/glossary/\{glossaryGuid\}/terms' has methods for the following verbs: get */ + ( + path: "/atlas/v2/glossary/{glossaryGuid}/terms", + glossaryGuid: string + ): GlossaryListTerms; + /** Resource for '/atlas/v2/glossary/\{glossaryGuid\}/terms/headers' has methods for the following verbs: get */ + ( + path: "/atlas/v2/glossary/{glossaryGuid}/terms/headers", + glossaryGuid: string + ): GlossaryListTermHeaders; + /** Resource for '/search/query' has methods for the following verbs: post */ + (path: "/search/query"): DiscoveryQuery; + /** Resource for '/search/suggest' has methods for the following verbs: post */ + (path: "/search/suggest"): DiscoverySuggest; + /** Resource for '/search/autocomplete' has methods for the following verbs: post */ + (path: "/search/autocomplete"): DiscoveryAutoComplete; + /** Resource for '/atlas/v2/lineage/\{guid\}' has methods for the following verbs: get */ + (path: "/atlas/v2/lineage/{guid}", guid: string): LineageGet; + /** Resource for '/lineage/\{guid\}/next' has methods for the following verbs: get */ + (path: "/lineage/{guid}/next", guid: string): LineageGetNextPage; + /** Resource for '/atlas/v2/lineage/uniqueAttribute/type/\{typeName\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/lineage/uniqueAttribute/type/{typeName}", + typeName: string + ): LineageGetByUniqueAttribute; + /** Resource for '/atlas/v2/relationship' has methods for the following verbs: post, put */ + (path: "/atlas/v2/relationship"): RelationshipCreate; + /** Resource for '/atlas/v2/relationship/guid/\{guid\}' has methods for the following verbs: get, delete */ + (path: "/atlas/v2/relationship/guid/{guid}", guid: string): RelationshipGet; + /** Resource for '/atlas/v2/types/businessmetadatadef/guid/\{guid\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/businessmetadatadef/guid/{guid}", + guid: string + ): TypeGetBusinessMetadataDefByGuid; + /** Resource for '/atlas/v2/types/businessmetadatadef/name/\{name\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/businessmetadatadef/name/{name}", + name: string + ): TypeGetBusinessMetadataDefByName; + /** Resource for '/atlas/v2/types/classificationdef/guid/\{guid\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/classificationdef/guid/{guid}", + guid: string + ): TypeGetClassificationDefByGuid; + /** Resource for '/atlas/v2/types/classificationdef/name/\{name\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/classificationdef/name/{name}", + name: string + ): TypeGetClassificationDefByName; + /** Resource for '/atlas/v2/types/entitydef/guid/\{guid\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/entitydef/guid/{guid}", + guid: string + ): TypeGetEntityDefByGuid; + /** Resource for '/atlas/v2/types/entitydef/name/\{name\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/entitydef/name/{name}", + name: string + ): TypeGetEntityDefByName; + /** Resource for '/atlas/v2/types/enumdef/guid/\{guid\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/enumdef/guid/{guid}", + guid: string + ): TypeGetEnumDefByGuid; + /** Resource for '/atlas/v2/types/enumdef/name/\{name\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/enumdef/name/{name}", + name: string + ): TypeGetEnumDefByName; + /** Resource for '/atlas/v2/types/relationshipdef/guid/\{guid\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/relationshipdef/guid/{guid}", + guid: string + ): TypeGetRelationshipDefByGuid; + /** Resource for '/atlas/v2/types/relationshipdef/name/\{name\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/relationshipdef/name/{name}", + name: string + ): TypeGetRelationshipDefByName; + /** Resource for '/atlas/v2/types/structdef/guid/\{guid\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/structdef/guid/{guid}", + guid: string + ): TypeGetStructDefByGuid; + /** Resource for '/atlas/v2/types/structdef/name/\{name\}' has methods for the following verbs: get */ + ( + path: "/atlas/v2/types/structdef/name/{name}", + name: string + ): TypeGetStructDefByName; + /** Resource for '/atlas/v2/types/typedef/guid/\{guid\}' has methods for the following verbs: get */ + (path: "/atlas/v2/types/typedef/guid/{guid}", guid: string): TypeGetByGuid; + /** Resource for '/atlas/v2/types/typedef/name/\{name\}' has methods for the following verbs: get, delete */ + (path: "/atlas/v2/types/typedef/name/{name}", name: string): TypeGetByName; + /** Resource for '/atlas/v2/types/typedefs' has methods for the following verbs: get, post, put, delete */ + (path: "/atlas/v2/types/typedefs"): TypeList; + /** Resource for '/atlas/v2/types/typedefs/headers' has methods for the following verbs: get */ + (path: "/atlas/v2/types/typedefs/headers"): TypeListHeaders; + /** Resource for '/types/termtemplatedef/guid/\{guid\}' has methods for the following verbs: get */ + ( + path: "/types/termtemplatedef/guid/{guid}", + guid: string + ): TypeGetTermTemplateDefByGuid; + /** Resource for '/types/termtemplatedef/name/\{name\}' has methods for the following verbs: get */ + ( + path: "/types/termtemplatedef/name/{name}", + name: string + ): TypeGetTermTemplateDefByName; +} + +export type PurviewDataMapClient = Client & { + path: Routes; +}; diff --git a/sdk/purview/purview-datamap-rest/src/index.ts b/sdk/purview/purview-datamap-rest/src/index.ts new file mode 100644 index 000000000000..07c784279c11 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/index.ts @@ -0,0 +1,15 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import PurviewDataMapClient from "./purviewDataMapClient"; + +export * from "./purviewDataMapClient"; +export * from "./parameters"; +export * from "./responses"; +export * from "./clientDefinitions"; +export * from "./isUnexpected"; +export * from "./models"; +export * from "./outputModels"; +export * from "./serializeHelper"; + +export default PurviewDataMapClient; diff --git a/sdk/purview/purview-datamap-rest/src/isUnexpected.ts b/sdk/purview/purview-datamap-rest/src/isUnexpected.ts new file mode 100644 index 000000000000..72db0ff4de81 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/isUnexpected.ts @@ -0,0 +1,1091 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import { + EntityCreateOrUpdate200Response, + EntityCreateOrUpdateDefaultResponse, + EntityListByGuids200Response, + EntityListByGuidsDefaultResponse, + EntityBulkCreateOrUpdate200Response, + EntityBulkCreateOrUpdateDefaultResponse, + EntityBulkDelete200Response, + EntityBulkDeleteDefaultResponse, + EntityAddClassification204Response, + EntityAddClassificationDefaultResponse, + EntityGet200Response, + EntityGetDefaultResponse, + EntityPartialUpdateAttributeByGuid200Response, + EntityPartialUpdateAttributeByGuidDefaultResponse, + EntityDeleteOperation200Response, + EntityDeleteOperationDefaultResponse, + EntityGetClassification200Response, + EntityGetClassificationDefaultResponse, + EntityRemoveClassification204Response, + EntityRemoveClassificationDefaultResponse, + EntityGetClassifications200Response, + EntityGetClassificationsDefaultResponse, + EntityAddClassifications204Response, + EntityAddClassificationsDefaultResponse, + EntityUpdateClassifications204Response, + EntityUpdateClassificationsDefaultResponse, + EntityGetByUniqueAttributes200Response, + EntityGetByUniqueAttributesDefaultResponse, + EntityPartialUpdateByUniqueAttributes200Response, + EntityPartialUpdateByUniqueAttributesDefaultResponse, + EntityDeleteByUniqueAttribute200Response, + EntityDeleteByUniqueAttributeDefaultResponse, + EntityRemoveClassificationByUniqueAttribute204Response, + EntityRemoveClassificationByUniqueAttributeDefaultResponse, + EntityAddClassificationsByUniqueAttribute204Response, + EntityAddClassificationsByUniqueAttributeDefaultResponse, + EntityUpdateClassificationsByUniqueAttribute204Response, + EntityUpdateClassificationsByUniqueAttributeDefaultResponse, + EntityBulkSetClassifications200Response, + EntityBulkSetClassificationsDefaultResponse, + EntityListByUniqueAttributes200Response, + EntityListByUniqueAttributesDefaultResponse, + EntityGetHeader200Response, + EntityGetHeaderDefaultResponse, + EntityRemoveBusinessMetadata204Response, + EntityRemoveBusinessMetadataDefaultResponse, + EntityAddOrUpdateBusinessMetadata204Response, + EntityAddOrUpdateBusinessMetadataDefaultResponse, + EntityRemoveBusinessMetadataAttributes204Response, + EntityRemoveBusinessMetadataAttributesDefaultResponse, + EntityAddOrUpdateBusinessMetadataAttributes204Response, + EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse, + EntityGetSampleBusinessMetadataTemplate200Response, + EntityGetSampleBusinessMetadataTemplateDefaultResponse, + EntityImportBusinessMetadata200Response, + EntityImportBusinessMetadataDefaultResponse, + EntityRemoveLabels204Response, + EntityRemoveLabelsDefaultResponse, + EntitySetLabels204Response, + EntitySetLabelsDefaultResponse, + EntityAddLabel204Response, + EntityAddLabelDefaultResponse, + EntityRemoveLabelsByUniqueAttribute204Response, + EntityRemoveLabelsByUniqueAttributeDefaultResponse, + EntitySetLabelsByUniqueAttribute204Response, + EntitySetLabelsByUniqueAttributeDefaultResponse, + EntityAddLabelsByUniqueAttribute204Response, + EntityAddLabelsByUniqueAttributeDefaultResponse, + EntityMoveEntitiesToCollection200Response, + EntityMoveEntitiesToCollectionDefaultResponse, + GlossaryList200Response, + GlossaryListDefaultResponse, + GlossaryCreate200Response, + GlossaryCreateDefaultResponse, + GlossaryCreateCategories200Response, + GlossaryCreateCategoriesDefaultResponse, + GlossaryCreateCategory200Response, + GlossaryCreateCategoryDefaultResponse, + GlossaryGetCategory200Response, + GlossaryGetCategoryDefaultResponse, + GlossaryUpdateCategory200Response, + GlossaryUpdateCategoryDefaultResponse, + GlossaryDeleteCategory204Response, + GlossaryDeleteCategoryDefaultResponse, + GlossaryPartialUpdateCategory200Response, + GlossaryPartialUpdateCategoryDefaultResponse, + GlossaryListRelatedCategories200Response, + GlossaryListRelatedCategoriesDefaultResponse, + GlossaryListCategoryTerms200Response, + GlossaryListCategoryTermsDefaultResponse, + GlossaryCreateTerm200Response, + GlossaryCreateTermDefaultResponse, + GlossaryGetTerm200Response, + GlossaryGetTermDefaultResponse, + GlossaryUpdateTerm200Response, + GlossaryUpdateTermDefaultResponse, + GlossaryDeleteTerm204Response, + GlossaryDeleteTermDefaultResponse, + GlossaryPartialUpdateTerm200Response, + GlossaryPartialUpdateTermDefaultResponse, + GlossaryCreateTerms200Response, + GlossaryCreateTermsDefaultResponse, + GlossaryListEntitiesAssignedWithTerm200Response, + GlossaryListEntitiesAssignedWithTermDefaultResponse, + GlossaryAssignTermToEntities204Response, + GlossaryAssignTermToEntitiesDefaultResponse, + GlossaryDeleteTermAssignmentFromEntities204Response, + GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse, + GlossaryListRelatedTerms200Response, + GlossaryListRelatedTermsDefaultResponse, + GlossaryGet200Response, + GlossaryGetDefaultResponse, + GlossaryUpdate200Response, + GlossaryUpdateDefaultResponse, + GlossaryDeleteOperation204Response, + GlossaryDeleteOperationDefaultResponse, + GlossaryListCategories200Response, + GlossaryListCategoriesDefaultResponse, + GlossaryListCategoriesHeaders200Response, + GlossaryListCategoriesHeadersDefaultResponse, + GlossaryGetDetailed200Response, + GlossaryGetDetailedDefaultResponse, + GlossaryPartialUpdate200Response, + GlossaryPartialUpdateDefaultResponse, + GlossaryListTerms200Response, + GlossaryListTermsDefaultResponse, + GlossaryListTermHeaders200Response, + GlossaryListTermHeadersDefaultResponse, + DiscoveryQuery200Response, + DiscoveryQueryDefaultResponse, + DiscoverySuggest200Response, + DiscoverySuggestDefaultResponse, + DiscoveryAutoComplete200Response, + DiscoveryAutoCompleteDefaultResponse, + LineageGet200Response, + LineageGetDefaultResponse, + LineageGetNextPage200Response, + LineageGetNextPageDefaultResponse, + LineageGetByUniqueAttribute200Response, + LineageGetByUniqueAttributeDefaultResponse, + RelationshipCreate200Response, + RelationshipCreateDefaultResponse, + RelationshipUpdate200Response, + RelationshipUpdateDefaultResponse, + RelationshipGet200Response, + RelationshipGetDefaultResponse, + RelationshipDeleteOperation204Response, + RelationshipDeleteOperationDefaultResponse, + TypeGetBusinessMetadataDefByGuid200Response, + TypeGetBusinessMetadataDefByGuidDefaultResponse, + TypeGetBusinessMetadataDefByName200Response, + TypeGetBusinessMetadataDefByNameDefaultResponse, + TypeGetClassificationDefByGuid200Response, + TypeGetClassificationDefByGuidDefaultResponse, + TypeGetClassificationDefByName200Response, + TypeGetClassificationDefByNameDefaultResponse, + TypeGetEntityDefByGuid200Response, + TypeGetEntityDefByGuidDefaultResponse, + TypeGetEntityDefByName200Response, + TypeGetEntityDefByNameDefaultResponse, + TypeGetEnumDefByGuid200Response, + TypeGetEnumDefByGuidDefaultResponse, + TypeGetEnumDefByName200Response, + TypeGetEnumDefByNameDefaultResponse, + TypeGetRelationshipDefByGuid200Response, + TypeGetRelationshipDefByGuidDefaultResponse, + TypeGetRelationshipDefByName200Response, + TypeGetRelationshipDefByNameDefaultResponse, + TypeGetStructDefByGuid200Response, + TypeGetStructDefByGuidDefaultResponse, + TypeGetStructDefByName200Response, + TypeGetStructDefByNameDefaultResponse, + TypeGetByGuid200Response, + TypeGetByGuidDefaultResponse, + TypeGetByName200Response, + TypeGetByNameDefaultResponse, + TypeDeleteOperation204Response, + TypeDeleteOperationDefaultResponse, + TypeList200Response, + TypeListDefaultResponse, + TypeBulkCreate200Response, + TypeBulkCreateDefaultResponse, + TypeBulkUpdate200Response, + TypeBulkUpdateDefaultResponse, + TypeBulkDelete204Response, + TypeBulkDeleteDefaultResponse, + TypeListHeaders200Response, + TypeListHeadersDefaultResponse, + TypeGetTermTemplateDefByGuid200Response, + TypeGetTermTemplateDefByGuidDefaultResponse, + TypeGetTermTemplateDefByName200Response, + TypeGetTermTemplateDefByNameDefaultResponse, +} from "./responses"; + +const responseMap: Record = { + "POST /atlas/v2/entity": ["200"], + "GET /atlas/v2/entity/bulk": ["200"], + "POST /atlas/v2/entity/bulk": ["200"], + "DELETE /atlas/v2/entity/bulk": ["200"], + "POST /atlas/v2/entity/bulk/classification": ["204"], + "GET /atlas/v2/entity/guid/{guid}": ["200"], + "PUT /atlas/v2/entity/guid/{guid}": ["200"], + "DELETE /atlas/v2/entity/guid/{guid}": ["200"], + "GET /atlas/v2/entity/guid/{guid}/classification/{classificationName}": [ + "200", + ], + "DELETE /atlas/v2/entity/guid/{guid}/classification/{classificationName}": [ + "204", + ], + "GET /atlas/v2/entity/guid/{guid}/classifications": ["200"], + "POST /atlas/v2/entity/guid/{guid}/classifications": ["204"], + "PUT /atlas/v2/entity/guid/{guid}/classifications": ["204"], + "GET /atlas/v2/entity/uniqueAttribute/type/{typeName}": ["200"], + "PUT /atlas/v2/entity/uniqueAttribute/type/{typeName}": ["200"], + "DELETE /atlas/v2/entity/uniqueAttribute/type/{typeName}": ["200"], + "DELETE /atlas/v2/entity/uniqueAttribute/type/{typeName}/classification/{classificationName}": + ["204"], + "POST /atlas/v2/entity/uniqueAttribute/type/{typeName}/classifications": [ + "204", + ], + "PUT /atlas/v2/entity/uniqueAttribute/type/{typeName}/classifications": [ + "204", + ], + "POST /atlas/v2/entity/bulk/setClassifications": ["200"], + "GET /atlas/v2/entity/bulk/uniqueAttribute/type/{typeName}": ["200"], + "GET /atlas/v2/entity/guid/{guid}/header": ["200"], + "DELETE /atlas/v2/entity/guid/{guid}/businessmetadata": ["204"], + "POST /atlas/v2/entity/guid/{guid}/businessmetadata": ["204"], + "DELETE /atlas/v2/entity/guid/{guid}/businessmetadata/{bmName}": ["204"], + "POST /atlas/v2/entity/guid/{guid}/businessmetadata/{bmName}": ["204"], + "GET /atlas/v2/entity/businessmetadata/import/template": ["200"], + "POST /atlas/v2/entity/businessmetadata/import": ["200"], + "DELETE /atlas/v2/entity/guid/{guid}/labels": ["204"], + "POST /atlas/v2/entity/guid/{guid}/labels": ["204"], + "PUT /atlas/v2/entity/guid/{guid}/labels": ["204"], + "DELETE /atlas/v2/entity/uniqueAttribute/type/{typeName}/labels": ["204"], + "POST /atlas/v2/entity/uniqueAttribute/type/{typeName}/labels": ["204"], + "PUT /atlas/v2/entity/uniqueAttribute/type/{typeName}/labels": ["204"], + "POST /entity/moveTo": ["200"], + "GET /atlas/v2/glossary": ["200"], + "POST /atlas/v2/glossary": ["200"], + "POST /atlas/v2/glossary/categories": ["200"], + "POST /atlas/v2/glossary/category": ["200"], + "GET /atlas/v2/glossary/category/{categoryGuid}": ["200"], + "PUT /atlas/v2/glossary/category/{categoryGuid}": ["200"], + "DELETE /atlas/v2/glossary/category/{categoryGuid}": ["204"], + "PUT /atlas/v2/glossary/category/{categoryGuid}/partial": ["200"], + "GET /atlas/v2/glossary/category/{categoryGuid}/related": ["200"], + "GET /atlas/v2/glossary/category/{categoryGuid}/terms": ["200"], + "POST /atlas/v2/glossary/term": ["200"], + "GET /atlas/v2/glossary/term/{termGuid}": ["200"], + "PUT /atlas/v2/glossary/term/{termGuid}": ["200"], + "DELETE /atlas/v2/glossary/term/{termGuid}": ["204"], + "PUT /atlas/v2/glossary/term/{termGuid}/partial": ["200"], + "POST /atlas/v2/glossary/terms": ["200"], + "GET /atlas/v2/glossary/terms/{termGuid}/assignedEntities": ["200"], + "POST /atlas/v2/glossary/terms/{termGuid}/assignedEntities": ["204"], + "DELETE /atlas/v2/glossary/terms/{termGuid}/assignedEntities": ["204"], + "GET /atlas/v2/glossary/terms/{termGuid}/related": ["200"], + "GET /atlas/v2/glossary/{glossaryGuid}": ["200"], + "PUT /atlas/v2/glossary/{glossaryGuid}": ["200"], + "DELETE /atlas/v2/glossary/{glossaryGuid}": ["204"], + "GET /atlas/v2/glossary/{glossaryGuid}/categories": ["200"], + "GET /atlas/v2/glossary/{glossaryGuid}/categories/headers": ["200"], + "GET /atlas/v2/glossary/{glossaryGuid}/detailed": ["200"], + "PUT /atlas/v2/glossary/{glossaryGuid}/partial": ["200"], + "GET /atlas/v2/glossary/{glossaryGuid}/terms": ["200"], + "GET /atlas/v2/glossary/{glossaryGuid}/terms/headers": ["200"], + "POST /search/query": ["200"], + "POST /search/suggest": ["200"], + "POST /search/autocomplete": ["200"], + "GET /atlas/v2/lineage/{guid}": ["200"], + "GET /lineage/{guid}/next": ["200"], + "GET /atlas/v2/lineage/uniqueAttribute/type/{typeName}": ["200"], + "POST /atlas/v2/relationship": ["200"], + "PUT /atlas/v2/relationship": ["200"], + "GET /atlas/v2/relationship/guid/{guid}": ["200"], + "DELETE /atlas/v2/relationship/guid/{guid}": ["204"], + "GET /atlas/v2/types/businessmetadatadef/guid/{guid}": ["200"], + "GET /atlas/v2/types/businessmetadatadef/name/{name}": ["200"], + "GET /atlas/v2/types/classificationdef/guid/{guid}": ["200"], + "GET /atlas/v2/types/classificationdef/name/{name}": ["200"], + "GET /atlas/v2/types/entitydef/guid/{guid}": ["200"], + "GET /atlas/v2/types/entitydef/name/{name}": ["200"], + "GET /atlas/v2/types/enumdef/guid/{guid}": ["200"], + "GET /atlas/v2/types/enumdef/name/{name}": ["200"], + "GET /atlas/v2/types/relationshipdef/guid/{guid}": ["200"], + "GET /atlas/v2/types/relationshipdef/name/{name}": ["200"], + "GET /atlas/v2/types/structdef/guid/{guid}": ["200"], + "GET /atlas/v2/types/structdef/name/{name}": ["200"], + "GET /atlas/v2/types/typedef/guid/{guid}": ["200"], + "GET /atlas/v2/types/typedef/name/{name}": ["200"], + "DELETE /atlas/v2/types/typedef/name/{name}": ["204"], + "GET /atlas/v2/types/typedefs": ["200"], + "POST /atlas/v2/types/typedefs": ["200"], + "PUT /atlas/v2/types/typedefs": ["200"], + "DELETE /atlas/v2/types/typedefs": ["204"], + "GET /atlas/v2/types/typedefs/headers": ["200"], + "GET /types/termtemplatedef/guid/{guid}": ["200"], + "GET /types/termtemplatedef/name/{name}": ["200"], +}; + +export function isUnexpected( + response: + | EntityCreateOrUpdate200Response + | EntityCreateOrUpdateDefaultResponse +): response is EntityCreateOrUpdateDefaultResponse; +export function isUnexpected( + response: EntityListByGuids200Response | EntityListByGuidsDefaultResponse +): response is EntityListByGuidsDefaultResponse; +export function isUnexpected( + response: + | EntityBulkCreateOrUpdate200Response + | EntityBulkCreateOrUpdateDefaultResponse +): response is EntityBulkCreateOrUpdateDefaultResponse; +export function isUnexpected( + response: EntityBulkDelete200Response | EntityBulkDeleteDefaultResponse +): response is EntityBulkDeleteDefaultResponse; +export function isUnexpected( + response: + | EntityAddClassification204Response + | EntityAddClassificationDefaultResponse +): response is EntityAddClassificationDefaultResponse; +export function isUnexpected( + response: EntityGet200Response | EntityGetDefaultResponse +): response is EntityGetDefaultResponse; +export function isUnexpected( + response: + | EntityPartialUpdateAttributeByGuid200Response + | EntityPartialUpdateAttributeByGuidDefaultResponse +): response is EntityPartialUpdateAttributeByGuidDefaultResponse; +export function isUnexpected( + response: + | EntityDeleteOperation200Response + | EntityDeleteOperationDefaultResponse +): response is EntityDeleteOperationDefaultResponse; +export function isUnexpected( + response: + | EntityGetClassification200Response + | EntityGetClassificationDefaultResponse +): response is EntityGetClassificationDefaultResponse; +export function isUnexpected( + response: + | EntityRemoveClassification204Response + | EntityRemoveClassificationDefaultResponse +): response is EntityRemoveClassificationDefaultResponse; +export function isUnexpected( + response: + | EntityGetClassifications200Response + | EntityGetClassificationsDefaultResponse +): response is EntityGetClassificationsDefaultResponse; +export function isUnexpected( + response: + | EntityAddClassifications204Response + | EntityAddClassificationsDefaultResponse +): response is EntityAddClassificationsDefaultResponse; +export function isUnexpected( + response: + | EntityUpdateClassifications204Response + | EntityUpdateClassificationsDefaultResponse +): response is EntityUpdateClassificationsDefaultResponse; +export function isUnexpected( + response: + | EntityGetByUniqueAttributes200Response + | EntityGetByUniqueAttributesDefaultResponse +): response is EntityGetByUniqueAttributesDefaultResponse; +export function isUnexpected( + response: + | EntityPartialUpdateByUniqueAttributes200Response + | EntityPartialUpdateByUniqueAttributesDefaultResponse +): response is EntityPartialUpdateByUniqueAttributesDefaultResponse; +export function isUnexpected( + response: + | EntityDeleteByUniqueAttribute200Response + | EntityDeleteByUniqueAttributeDefaultResponse +): response is EntityDeleteByUniqueAttributeDefaultResponse; +export function isUnexpected( + response: + | EntityRemoveClassificationByUniqueAttribute204Response + | EntityRemoveClassificationByUniqueAttributeDefaultResponse +): response is EntityRemoveClassificationByUniqueAttributeDefaultResponse; +export function isUnexpected( + response: + | EntityAddClassificationsByUniqueAttribute204Response + | EntityAddClassificationsByUniqueAttributeDefaultResponse +): response is EntityAddClassificationsByUniqueAttributeDefaultResponse; +export function isUnexpected( + response: + | EntityUpdateClassificationsByUniqueAttribute204Response + | EntityUpdateClassificationsByUniqueAttributeDefaultResponse +): response is EntityUpdateClassificationsByUniqueAttributeDefaultResponse; +export function isUnexpected( + response: + | EntityBulkSetClassifications200Response + | EntityBulkSetClassificationsDefaultResponse +): response is EntityBulkSetClassificationsDefaultResponse; +export function isUnexpected( + response: + | EntityListByUniqueAttributes200Response + | EntityListByUniqueAttributesDefaultResponse +): response is EntityListByUniqueAttributesDefaultResponse; +export function isUnexpected( + response: EntityGetHeader200Response | EntityGetHeaderDefaultResponse +): response is EntityGetHeaderDefaultResponse; +export function isUnexpected( + response: + | EntityRemoveBusinessMetadata204Response + | EntityRemoveBusinessMetadataDefaultResponse +): response is EntityRemoveBusinessMetadataDefaultResponse; +export function isUnexpected( + response: + | EntityAddOrUpdateBusinessMetadata204Response + | EntityAddOrUpdateBusinessMetadataDefaultResponse +): response is EntityAddOrUpdateBusinessMetadataDefaultResponse; +export function isUnexpected( + response: + | EntityRemoveBusinessMetadataAttributes204Response + | EntityRemoveBusinessMetadataAttributesDefaultResponse +): response is EntityRemoveBusinessMetadataAttributesDefaultResponse; +export function isUnexpected( + response: + | EntityAddOrUpdateBusinessMetadataAttributes204Response + | EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse +): response is EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse; +export function isUnexpected( + response: + | EntityGetSampleBusinessMetadataTemplate200Response + | EntityGetSampleBusinessMetadataTemplateDefaultResponse +): response is EntityGetSampleBusinessMetadataTemplateDefaultResponse; +export function isUnexpected( + response: + | EntityImportBusinessMetadata200Response + | EntityImportBusinessMetadataDefaultResponse +): response is EntityImportBusinessMetadataDefaultResponse; +export function isUnexpected( + response: EntityRemoveLabels204Response | EntityRemoveLabelsDefaultResponse +): response is EntityRemoveLabelsDefaultResponse; +export function isUnexpected( + response: EntitySetLabels204Response | EntitySetLabelsDefaultResponse +): response is EntitySetLabelsDefaultResponse; +export function isUnexpected( + response: EntityAddLabel204Response | EntityAddLabelDefaultResponse +): response is EntityAddLabelDefaultResponse; +export function isUnexpected( + response: + | EntityRemoveLabelsByUniqueAttribute204Response + | EntityRemoveLabelsByUniqueAttributeDefaultResponse +): response is EntityRemoveLabelsByUniqueAttributeDefaultResponse; +export function isUnexpected( + response: + | EntitySetLabelsByUniqueAttribute204Response + | EntitySetLabelsByUniqueAttributeDefaultResponse +): response is EntitySetLabelsByUniqueAttributeDefaultResponse; +export function isUnexpected( + response: + | EntityAddLabelsByUniqueAttribute204Response + | EntityAddLabelsByUniqueAttributeDefaultResponse +): response is EntityAddLabelsByUniqueAttributeDefaultResponse; +export function isUnexpected( + response: + | EntityMoveEntitiesToCollection200Response + | EntityMoveEntitiesToCollectionDefaultResponse +): response is EntityMoveEntitiesToCollectionDefaultResponse; +export function isUnexpected( + response: GlossaryList200Response | GlossaryListDefaultResponse +): response is GlossaryListDefaultResponse; +export function isUnexpected( + response: GlossaryCreate200Response | GlossaryCreateDefaultResponse +): response is GlossaryCreateDefaultResponse; +export function isUnexpected( + response: + | GlossaryCreateCategories200Response + | GlossaryCreateCategoriesDefaultResponse +): response is GlossaryCreateCategoriesDefaultResponse; +export function isUnexpected( + response: + | GlossaryCreateCategory200Response + | GlossaryCreateCategoryDefaultResponse +): response is GlossaryCreateCategoryDefaultResponse; +export function isUnexpected( + response: GlossaryGetCategory200Response | GlossaryGetCategoryDefaultResponse +): response is GlossaryGetCategoryDefaultResponse; +export function isUnexpected( + response: + | GlossaryUpdateCategory200Response + | GlossaryUpdateCategoryDefaultResponse +): response is GlossaryUpdateCategoryDefaultResponse; +export function isUnexpected( + response: + | GlossaryDeleteCategory204Response + | GlossaryDeleteCategoryDefaultResponse +): response is GlossaryDeleteCategoryDefaultResponse; +export function isUnexpected( + response: + | GlossaryPartialUpdateCategory200Response + | GlossaryPartialUpdateCategoryDefaultResponse +): response is GlossaryPartialUpdateCategoryDefaultResponse; +export function isUnexpected( + response: + | GlossaryListRelatedCategories200Response + | GlossaryListRelatedCategoriesDefaultResponse +): response is GlossaryListRelatedCategoriesDefaultResponse; +export function isUnexpected( + response: + | GlossaryListCategoryTerms200Response + | GlossaryListCategoryTermsDefaultResponse +): response is GlossaryListCategoryTermsDefaultResponse; +export function isUnexpected( + response: GlossaryCreateTerm200Response | GlossaryCreateTermDefaultResponse +): response is GlossaryCreateTermDefaultResponse; +export function isUnexpected( + response: GlossaryGetTerm200Response | GlossaryGetTermDefaultResponse +): response is GlossaryGetTermDefaultResponse; +export function isUnexpected( + response: GlossaryUpdateTerm200Response | GlossaryUpdateTermDefaultResponse +): response is GlossaryUpdateTermDefaultResponse; +export function isUnexpected( + response: GlossaryDeleteTerm204Response | GlossaryDeleteTermDefaultResponse +): response is GlossaryDeleteTermDefaultResponse; +export function isUnexpected( + response: + | GlossaryPartialUpdateTerm200Response + | GlossaryPartialUpdateTermDefaultResponse +): response is GlossaryPartialUpdateTermDefaultResponse; +export function isUnexpected( + response: GlossaryCreateTerms200Response | GlossaryCreateTermsDefaultResponse +): response is GlossaryCreateTermsDefaultResponse; +export function isUnexpected( + response: + | GlossaryListEntitiesAssignedWithTerm200Response + | GlossaryListEntitiesAssignedWithTermDefaultResponse +): response is GlossaryListEntitiesAssignedWithTermDefaultResponse; +export function isUnexpected( + response: + | GlossaryAssignTermToEntities204Response + | GlossaryAssignTermToEntitiesDefaultResponse +): response is GlossaryAssignTermToEntitiesDefaultResponse; +export function isUnexpected( + response: + | GlossaryDeleteTermAssignmentFromEntities204Response + | GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse +): response is GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse; +export function isUnexpected( + response: + | GlossaryListRelatedTerms200Response + | GlossaryListRelatedTermsDefaultResponse +): response is GlossaryListRelatedTermsDefaultResponse; +export function isUnexpected( + response: GlossaryGet200Response | GlossaryGetDefaultResponse +): response is GlossaryGetDefaultResponse; +export function isUnexpected( + response: GlossaryUpdate200Response | GlossaryUpdateDefaultResponse +): response is GlossaryUpdateDefaultResponse; +export function isUnexpected( + response: + | GlossaryDeleteOperation204Response + | GlossaryDeleteOperationDefaultResponse +): response is GlossaryDeleteOperationDefaultResponse; +export function isUnexpected( + response: + | GlossaryListCategories200Response + | GlossaryListCategoriesDefaultResponse +): response is GlossaryListCategoriesDefaultResponse; +export function isUnexpected( + response: + | GlossaryListCategoriesHeaders200Response + | GlossaryListCategoriesHeadersDefaultResponse +): response is GlossaryListCategoriesHeadersDefaultResponse; +export function isUnexpected( + response: GlossaryGetDetailed200Response | GlossaryGetDetailedDefaultResponse +): response is GlossaryGetDetailedDefaultResponse; +export function isUnexpected( + response: + | GlossaryPartialUpdate200Response + | GlossaryPartialUpdateDefaultResponse +): response is GlossaryPartialUpdateDefaultResponse; +export function isUnexpected( + response: GlossaryListTerms200Response | GlossaryListTermsDefaultResponse +): response is GlossaryListTermsDefaultResponse; +export function isUnexpected( + response: + | GlossaryListTermHeaders200Response + | GlossaryListTermHeadersDefaultResponse +): response is GlossaryListTermHeadersDefaultResponse; +export function isUnexpected( + response: DiscoveryQuery200Response | DiscoveryQueryDefaultResponse +): response is DiscoveryQueryDefaultResponse; +export function isUnexpected( + response: DiscoverySuggest200Response | DiscoverySuggestDefaultResponse +): response is DiscoverySuggestDefaultResponse; +export function isUnexpected( + response: + | DiscoveryAutoComplete200Response + | DiscoveryAutoCompleteDefaultResponse +): response is DiscoveryAutoCompleteDefaultResponse; +export function isUnexpected( + response: LineageGet200Response | LineageGetDefaultResponse +): response is LineageGetDefaultResponse; +export function isUnexpected( + response: LineageGetNextPage200Response | LineageGetNextPageDefaultResponse +): response is LineageGetNextPageDefaultResponse; +export function isUnexpected( + response: + | LineageGetByUniqueAttribute200Response + | LineageGetByUniqueAttributeDefaultResponse +): response is LineageGetByUniqueAttributeDefaultResponse; +export function isUnexpected( + response: RelationshipCreate200Response | RelationshipCreateDefaultResponse +): response is RelationshipCreateDefaultResponse; +export function isUnexpected( + response: RelationshipUpdate200Response | RelationshipUpdateDefaultResponse +): response is RelationshipUpdateDefaultResponse; +export function isUnexpected( + response: RelationshipGet200Response | RelationshipGetDefaultResponse +): response is RelationshipGetDefaultResponse; +export function isUnexpected( + response: + | RelationshipDeleteOperation204Response + | RelationshipDeleteOperationDefaultResponse +): response is RelationshipDeleteOperationDefaultResponse; +export function isUnexpected( + response: + | TypeGetBusinessMetadataDefByGuid200Response + | TypeGetBusinessMetadataDefByGuidDefaultResponse +): response is TypeGetBusinessMetadataDefByGuidDefaultResponse; +export function isUnexpected( + response: + | TypeGetBusinessMetadataDefByName200Response + | TypeGetBusinessMetadataDefByNameDefaultResponse +): response is TypeGetBusinessMetadataDefByNameDefaultResponse; +export function isUnexpected( + response: + | TypeGetClassificationDefByGuid200Response + | TypeGetClassificationDefByGuidDefaultResponse +): response is TypeGetClassificationDefByGuidDefaultResponse; +export function isUnexpected( + response: + | TypeGetClassificationDefByName200Response + | TypeGetClassificationDefByNameDefaultResponse +): response is TypeGetClassificationDefByNameDefaultResponse; +export function isUnexpected( + response: + | TypeGetEntityDefByGuid200Response + | TypeGetEntityDefByGuidDefaultResponse +): response is TypeGetEntityDefByGuidDefaultResponse; +export function isUnexpected( + response: + | TypeGetEntityDefByName200Response + | TypeGetEntityDefByNameDefaultResponse +): response is TypeGetEntityDefByNameDefaultResponse; +export function isUnexpected( + response: + | TypeGetEnumDefByGuid200Response + | TypeGetEnumDefByGuidDefaultResponse +): response is TypeGetEnumDefByGuidDefaultResponse; +export function isUnexpected( + response: + | TypeGetEnumDefByName200Response + | TypeGetEnumDefByNameDefaultResponse +): response is TypeGetEnumDefByNameDefaultResponse; +export function isUnexpected( + response: + | TypeGetRelationshipDefByGuid200Response + | TypeGetRelationshipDefByGuidDefaultResponse +): response is TypeGetRelationshipDefByGuidDefaultResponse; +export function isUnexpected( + response: + | TypeGetRelationshipDefByName200Response + | TypeGetRelationshipDefByNameDefaultResponse +): response is TypeGetRelationshipDefByNameDefaultResponse; +export function isUnexpected( + response: + | TypeGetStructDefByGuid200Response + | TypeGetStructDefByGuidDefaultResponse +): response is TypeGetStructDefByGuidDefaultResponse; +export function isUnexpected( + response: + | TypeGetStructDefByName200Response + | TypeGetStructDefByNameDefaultResponse +): response is TypeGetStructDefByNameDefaultResponse; +export function isUnexpected( + response: TypeGetByGuid200Response | TypeGetByGuidDefaultResponse +): response is TypeGetByGuidDefaultResponse; +export function isUnexpected( + response: TypeGetByName200Response | TypeGetByNameDefaultResponse +): response is TypeGetByNameDefaultResponse; +export function isUnexpected( + response: TypeDeleteOperation204Response | TypeDeleteOperationDefaultResponse +): response is TypeDeleteOperationDefaultResponse; +export function isUnexpected( + response: TypeList200Response | TypeListDefaultResponse +): response is TypeListDefaultResponse; +export function isUnexpected( + response: TypeBulkCreate200Response | TypeBulkCreateDefaultResponse +): response is TypeBulkCreateDefaultResponse; +export function isUnexpected( + response: TypeBulkUpdate200Response | TypeBulkUpdateDefaultResponse +): response is TypeBulkUpdateDefaultResponse; +export function isUnexpected( + response: TypeBulkDelete204Response | TypeBulkDeleteDefaultResponse +): response is TypeBulkDeleteDefaultResponse; +export function isUnexpected( + response: TypeListHeaders200Response | TypeListHeadersDefaultResponse +): response is TypeListHeadersDefaultResponse; +export function isUnexpected( + response: + | TypeGetTermTemplateDefByGuid200Response + | TypeGetTermTemplateDefByGuidDefaultResponse +): response is TypeGetTermTemplateDefByGuidDefaultResponse; +export function isUnexpected( + response: + | TypeGetTermTemplateDefByName200Response + | TypeGetTermTemplateDefByNameDefaultResponse +): response is TypeGetTermTemplateDefByNameDefaultResponse; +export function isUnexpected( + response: + | EntityCreateOrUpdate200Response + | EntityCreateOrUpdateDefaultResponse + | EntityListByGuids200Response + | EntityListByGuidsDefaultResponse + | EntityBulkCreateOrUpdate200Response + | EntityBulkCreateOrUpdateDefaultResponse + | EntityBulkDelete200Response + | EntityBulkDeleteDefaultResponse + | EntityAddClassification204Response + | EntityAddClassificationDefaultResponse + | EntityGet200Response + | EntityGetDefaultResponse + | EntityPartialUpdateAttributeByGuid200Response + | EntityPartialUpdateAttributeByGuidDefaultResponse + | EntityDeleteOperation200Response + | EntityDeleteOperationDefaultResponse + | EntityGetClassification200Response + | EntityGetClassificationDefaultResponse + | EntityRemoveClassification204Response + | EntityRemoveClassificationDefaultResponse + | EntityGetClassifications200Response + | EntityGetClassificationsDefaultResponse + | EntityAddClassifications204Response + | EntityAddClassificationsDefaultResponse + | EntityUpdateClassifications204Response + | EntityUpdateClassificationsDefaultResponse + | EntityGetByUniqueAttributes200Response + | EntityGetByUniqueAttributesDefaultResponse + | EntityPartialUpdateByUniqueAttributes200Response + | EntityPartialUpdateByUniqueAttributesDefaultResponse + | EntityDeleteByUniqueAttribute200Response + | EntityDeleteByUniqueAttributeDefaultResponse + | EntityRemoveClassificationByUniqueAttribute204Response + | EntityRemoveClassificationByUniqueAttributeDefaultResponse + | EntityAddClassificationsByUniqueAttribute204Response + | EntityAddClassificationsByUniqueAttributeDefaultResponse + | EntityUpdateClassificationsByUniqueAttribute204Response + | EntityUpdateClassificationsByUniqueAttributeDefaultResponse + | EntityBulkSetClassifications200Response + | EntityBulkSetClassificationsDefaultResponse + | EntityListByUniqueAttributes200Response + | EntityListByUniqueAttributesDefaultResponse + | EntityGetHeader200Response + | EntityGetHeaderDefaultResponse + | EntityRemoveBusinessMetadata204Response + | EntityRemoveBusinessMetadataDefaultResponse + | EntityAddOrUpdateBusinessMetadata204Response + | EntityAddOrUpdateBusinessMetadataDefaultResponse + | EntityRemoveBusinessMetadataAttributes204Response + | EntityRemoveBusinessMetadataAttributesDefaultResponse + | EntityAddOrUpdateBusinessMetadataAttributes204Response + | EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse + | EntityGetSampleBusinessMetadataTemplate200Response + | EntityGetSampleBusinessMetadataTemplateDefaultResponse + | EntityImportBusinessMetadata200Response + | EntityImportBusinessMetadataDefaultResponse + | EntityRemoveLabels204Response + | EntityRemoveLabelsDefaultResponse + | EntitySetLabels204Response + | EntitySetLabelsDefaultResponse + | EntityAddLabel204Response + | EntityAddLabelDefaultResponse + | EntityRemoveLabelsByUniqueAttribute204Response + | EntityRemoveLabelsByUniqueAttributeDefaultResponse + | EntitySetLabelsByUniqueAttribute204Response + | EntitySetLabelsByUniqueAttributeDefaultResponse + | EntityAddLabelsByUniqueAttribute204Response + | EntityAddLabelsByUniqueAttributeDefaultResponse + | EntityMoveEntitiesToCollection200Response + | EntityMoveEntitiesToCollectionDefaultResponse + | GlossaryList200Response + | GlossaryListDefaultResponse + | GlossaryCreate200Response + | GlossaryCreateDefaultResponse + | GlossaryCreateCategories200Response + | GlossaryCreateCategoriesDefaultResponse + | GlossaryCreateCategory200Response + | GlossaryCreateCategoryDefaultResponse + | GlossaryGetCategory200Response + | GlossaryGetCategoryDefaultResponse + | GlossaryUpdateCategory200Response + | GlossaryUpdateCategoryDefaultResponse + | GlossaryDeleteCategory204Response + | GlossaryDeleteCategoryDefaultResponse + | GlossaryPartialUpdateCategory200Response + | GlossaryPartialUpdateCategoryDefaultResponse + | GlossaryListRelatedCategories200Response + | GlossaryListRelatedCategoriesDefaultResponse + | GlossaryListCategoryTerms200Response + | GlossaryListCategoryTermsDefaultResponse + | GlossaryCreateTerm200Response + | GlossaryCreateTermDefaultResponse + | GlossaryGetTerm200Response + | GlossaryGetTermDefaultResponse + | GlossaryUpdateTerm200Response + | GlossaryUpdateTermDefaultResponse + | GlossaryDeleteTerm204Response + | GlossaryDeleteTermDefaultResponse + | GlossaryPartialUpdateTerm200Response + | GlossaryPartialUpdateTermDefaultResponse + | GlossaryCreateTerms200Response + | GlossaryCreateTermsDefaultResponse + | GlossaryListEntitiesAssignedWithTerm200Response + | GlossaryListEntitiesAssignedWithTermDefaultResponse + | GlossaryAssignTermToEntities204Response + | GlossaryAssignTermToEntitiesDefaultResponse + | GlossaryDeleteTermAssignmentFromEntities204Response + | GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse + | GlossaryListRelatedTerms200Response + | GlossaryListRelatedTermsDefaultResponse + | GlossaryGet200Response + | GlossaryGetDefaultResponse + | GlossaryUpdate200Response + | GlossaryUpdateDefaultResponse + | GlossaryDeleteOperation204Response + | GlossaryDeleteOperationDefaultResponse + | GlossaryListCategories200Response + | GlossaryListCategoriesDefaultResponse + | GlossaryListCategoriesHeaders200Response + | GlossaryListCategoriesHeadersDefaultResponse + | GlossaryGetDetailed200Response + | GlossaryGetDetailedDefaultResponse + | GlossaryPartialUpdate200Response + | GlossaryPartialUpdateDefaultResponse + | GlossaryListTerms200Response + | GlossaryListTermsDefaultResponse + | GlossaryListTermHeaders200Response + | GlossaryListTermHeadersDefaultResponse + | DiscoveryQuery200Response + | DiscoveryQueryDefaultResponse + | DiscoverySuggest200Response + | DiscoverySuggestDefaultResponse + | DiscoveryAutoComplete200Response + | DiscoveryAutoCompleteDefaultResponse + | LineageGet200Response + | LineageGetDefaultResponse + | LineageGetNextPage200Response + | LineageGetNextPageDefaultResponse + | LineageGetByUniqueAttribute200Response + | LineageGetByUniqueAttributeDefaultResponse + | RelationshipCreate200Response + | RelationshipCreateDefaultResponse + | RelationshipUpdate200Response + | RelationshipUpdateDefaultResponse + | RelationshipGet200Response + | RelationshipGetDefaultResponse + | RelationshipDeleteOperation204Response + | RelationshipDeleteOperationDefaultResponse + | TypeGetBusinessMetadataDefByGuid200Response + | TypeGetBusinessMetadataDefByGuidDefaultResponse + | TypeGetBusinessMetadataDefByName200Response + | TypeGetBusinessMetadataDefByNameDefaultResponse + | TypeGetClassificationDefByGuid200Response + | TypeGetClassificationDefByGuidDefaultResponse + | TypeGetClassificationDefByName200Response + | TypeGetClassificationDefByNameDefaultResponse + | TypeGetEntityDefByGuid200Response + | TypeGetEntityDefByGuidDefaultResponse + | TypeGetEntityDefByName200Response + | TypeGetEntityDefByNameDefaultResponse + | TypeGetEnumDefByGuid200Response + | TypeGetEnumDefByGuidDefaultResponse + | TypeGetEnumDefByName200Response + | TypeGetEnumDefByNameDefaultResponse + | TypeGetRelationshipDefByGuid200Response + | TypeGetRelationshipDefByGuidDefaultResponse + | TypeGetRelationshipDefByName200Response + | TypeGetRelationshipDefByNameDefaultResponse + | TypeGetStructDefByGuid200Response + | TypeGetStructDefByGuidDefaultResponse + | TypeGetStructDefByName200Response + | TypeGetStructDefByNameDefaultResponse + | TypeGetByGuid200Response + | TypeGetByGuidDefaultResponse + | TypeGetByName200Response + | TypeGetByNameDefaultResponse + | TypeDeleteOperation204Response + | TypeDeleteOperationDefaultResponse + | TypeList200Response + | TypeListDefaultResponse + | TypeBulkCreate200Response + | TypeBulkCreateDefaultResponse + | TypeBulkUpdate200Response + | TypeBulkUpdateDefaultResponse + | TypeBulkDelete204Response + | TypeBulkDeleteDefaultResponse + | TypeListHeaders200Response + | TypeListHeadersDefaultResponse + | TypeGetTermTemplateDefByGuid200Response + | TypeGetTermTemplateDefByGuidDefaultResponse + | TypeGetTermTemplateDefByName200Response + | TypeGetTermTemplateDefByNameDefaultResponse +): response is + | EntityCreateOrUpdateDefaultResponse + | EntityListByGuidsDefaultResponse + | EntityBulkCreateOrUpdateDefaultResponse + | EntityBulkDeleteDefaultResponse + | EntityAddClassificationDefaultResponse + | EntityGetDefaultResponse + | EntityPartialUpdateAttributeByGuidDefaultResponse + | EntityDeleteOperationDefaultResponse + | EntityGetClassificationDefaultResponse + | EntityRemoveClassificationDefaultResponse + | EntityGetClassificationsDefaultResponse + | EntityAddClassificationsDefaultResponse + | EntityUpdateClassificationsDefaultResponse + | EntityGetByUniqueAttributesDefaultResponse + | EntityPartialUpdateByUniqueAttributesDefaultResponse + | EntityDeleteByUniqueAttributeDefaultResponse + | EntityRemoveClassificationByUniqueAttributeDefaultResponse + | EntityAddClassificationsByUniqueAttributeDefaultResponse + | EntityUpdateClassificationsByUniqueAttributeDefaultResponse + | EntityBulkSetClassificationsDefaultResponse + | EntityListByUniqueAttributesDefaultResponse + | EntityGetHeaderDefaultResponse + | EntityRemoveBusinessMetadataDefaultResponse + | EntityAddOrUpdateBusinessMetadataDefaultResponse + | EntityRemoveBusinessMetadataAttributesDefaultResponse + | EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse + | EntityGetSampleBusinessMetadataTemplateDefaultResponse + | EntityImportBusinessMetadataDefaultResponse + | EntityRemoveLabelsDefaultResponse + | EntitySetLabelsDefaultResponse + | EntityAddLabelDefaultResponse + | EntityRemoveLabelsByUniqueAttributeDefaultResponse + | EntitySetLabelsByUniqueAttributeDefaultResponse + | EntityAddLabelsByUniqueAttributeDefaultResponse + | EntityMoveEntitiesToCollectionDefaultResponse + | GlossaryListDefaultResponse + | GlossaryCreateDefaultResponse + | GlossaryCreateCategoriesDefaultResponse + | GlossaryCreateCategoryDefaultResponse + | GlossaryGetCategoryDefaultResponse + | GlossaryUpdateCategoryDefaultResponse + | GlossaryDeleteCategoryDefaultResponse + | GlossaryPartialUpdateCategoryDefaultResponse + | GlossaryListRelatedCategoriesDefaultResponse + | GlossaryListCategoryTermsDefaultResponse + | GlossaryCreateTermDefaultResponse + | GlossaryGetTermDefaultResponse + | GlossaryUpdateTermDefaultResponse + | GlossaryDeleteTermDefaultResponse + | GlossaryPartialUpdateTermDefaultResponse + | GlossaryCreateTermsDefaultResponse + | GlossaryListEntitiesAssignedWithTermDefaultResponse + | GlossaryAssignTermToEntitiesDefaultResponse + | GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse + | GlossaryListRelatedTermsDefaultResponse + | GlossaryGetDefaultResponse + | GlossaryUpdateDefaultResponse + | GlossaryDeleteOperationDefaultResponse + | GlossaryListCategoriesDefaultResponse + | GlossaryListCategoriesHeadersDefaultResponse + | GlossaryGetDetailedDefaultResponse + | GlossaryPartialUpdateDefaultResponse + | GlossaryListTermsDefaultResponse + | GlossaryListTermHeadersDefaultResponse + | DiscoveryQueryDefaultResponse + | DiscoverySuggestDefaultResponse + | DiscoveryAutoCompleteDefaultResponse + | LineageGetDefaultResponse + | LineageGetNextPageDefaultResponse + | LineageGetByUniqueAttributeDefaultResponse + | RelationshipCreateDefaultResponse + | RelationshipUpdateDefaultResponse + | RelationshipGetDefaultResponse + | RelationshipDeleteOperationDefaultResponse + | TypeGetBusinessMetadataDefByGuidDefaultResponse + | TypeGetBusinessMetadataDefByNameDefaultResponse + | TypeGetClassificationDefByGuidDefaultResponse + | TypeGetClassificationDefByNameDefaultResponse + | TypeGetEntityDefByGuidDefaultResponse + | TypeGetEntityDefByNameDefaultResponse + | TypeGetEnumDefByGuidDefaultResponse + | TypeGetEnumDefByNameDefaultResponse + | TypeGetRelationshipDefByGuidDefaultResponse + | TypeGetRelationshipDefByNameDefaultResponse + | TypeGetStructDefByGuidDefaultResponse + | TypeGetStructDefByNameDefaultResponse + | TypeGetByGuidDefaultResponse + | TypeGetByNameDefaultResponse + | TypeDeleteOperationDefaultResponse + | TypeListDefaultResponse + | TypeBulkCreateDefaultResponse + | TypeBulkUpdateDefaultResponse + | TypeBulkDeleteDefaultResponse + | TypeListHeadersDefaultResponse + | TypeGetTermTemplateDefByGuidDefaultResponse + | TypeGetTermTemplateDefByNameDefaultResponse { + const lroOriginal = response.headers["x-ms-original-url"]; + const url = new URL(lroOriginal ?? response.request.url); + const method = response.request.method; + let pathDetails = responseMap[`${method} ${url.pathname}`]; + if (!pathDetails) { + pathDetails = getParametrizedPathSuccess(method, url.pathname); + } + return !pathDetails.includes(response.status); +} + +function getParametrizedPathSuccess(method: string, path: string): string[] { + const pathParts = path.split("/"); + + // Traverse list to match the longest candidate + // matchedLen: the length of candidate path + // matchedValue: the matched status code array + let matchedLen = -1, + matchedValue: string[] = []; + + // Iterate the responseMap to find a match + for (const [key, value] of Object.entries(responseMap)) { + // Extracting the path from the map key which is in format + // GET /path/foo + if (!key.startsWith(method)) { + continue; + } + const candidatePath = getPathFromMapKey(key); + // Get each part of the url path + const candidateParts = candidatePath.split("/"); + + // track if we have found a match to return the values found. + let found = true; + for ( + let i = candidateParts.length - 1, j = pathParts.length - 1; + i >= 1 && j >= 1; + i--, j-- + ) { + if ( + candidateParts[i]?.startsWith("{") && + candidateParts[i]?.indexOf("}") !== -1 + ) { + const start = candidateParts[i]!.indexOf("}") + 1, + end = candidateParts[i]?.length; + // If the current part of the candidate is a "template" part + // Try to use the suffix of pattern to match the path + // {guid} ==> $ + // {guid}:export ==> :export$ + const isMatched = new RegExp( + `${candidateParts[i]?.slice(start, end)}` + ).test(pathParts[j] || ""); + + if (!isMatched) { + found = false; + break; + } + continue; + } + + // If the candidate part is not a template and + // the parts don't match mark the candidate as not found + // to move on with the next candidate path. + if (candidateParts[i] !== pathParts[j]) { + found = false; + break; + } + } + + // We finished evaluating the current candidate parts + // Update the matched value if and only if we found the longer pattern + if (found && candidatePath.length > matchedLen) { + matchedLen = candidatePath.length; + matchedValue = value; + } + } + + return matchedValue; +} + +function getPathFromMapKey(mapKey: string): string { + const pathStart = mapKey.indexOf("/"); + return mapKey.slice(pathStart); +} diff --git a/sdk/purview/purview-datamap-rest/src/logger.ts b/sdk/purview/purview-datamap-rest/src/logger.ts new file mode 100644 index 000000000000..07f964d81466 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/logger.ts @@ -0,0 +1,5 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import { createClientLogger } from "@azure/logger"; +export const logger = createClientLogger("purview-datamap"); diff --git a/sdk/purview/purview-datamap-rest/src/models.ts b/sdk/purview/purview-datamap-rest/src/models.ts new file mode 100644 index 000000000000..56652b1821b7 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/models.ts @@ -0,0 +1,1464 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +/** + * An instance of an entity along with extended info - like hive_table, + * hive_database. + */ +export interface AtlasEntityWithExtInfo { + /** The referred entities. */ + referredEntities?: Record; + /** An instance of an entity - like hive_table, hive_database. */ + entity?: AtlasEntity; +} + +/** An instance of an entity - like hive_table, hive_database. */ +export interface AtlasEntity { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** Business attributes */ + businessAttributes?: Record; + /** An array of classifications. */ + classifications?: Array; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** Custom Attribute */ + customAttributes?: Record; + /** The GUID of the entity. */ + guid?: string; + /** The home ID of the entity. */ + homeId?: string; + /** Whether it is a shell entity */ + isIncomplete?: boolean; + /** labels */ + labels?: string[]; + /** An array of term assignment headers indicating the meanings of the entity. */ + meanings?: Array; + /** Used to record the provenance of an instance of an entity or relationship. */ + provenanceType?: number; + /** Determines if there's a proxy. */ + proxy?: boolean; + /** The attributes of relationship. */ + relationshipAttributes?: Record; + /** + * Status of the entity - can be active or deleted. Deleted entities are not + * removed. + * + * Possible values: ACTIVE, DELETED + */ + status?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the entity. */ + version?: number; + /** The dictionary of contacts for entities. Key could be Expert or Owner. */ + contacts?: Record>; +} + +/** + * An instance of a classification; it doesn't have an identity, this object + * exists only when associated with an entity. + */ +export interface AtlasClassification { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The GUID of the entity. */ + entityGuid?: string; + /** + * Status of the entity - can be active or deleted. Deleted entities are not + * removed. + * + * Possible values: ACTIVE, DELETED + */ + entityStatus?: string; + /** Determines if propagations will be removed on entity deletion. */ + removePropagationsOnEntityDelete?: boolean; + /** An array of time boundaries indicating validity periods. */ + validityPeriods?: Array; +} + +/** Captures time-boundary details */ +export interface TimeBoundary { + /** The end of the time boundary. */ + endTime?: string; + /** The start of the time boundary. */ + startTime?: string; + /** The timezone of the time boundary. */ + timeZone?: string; +} + +/** The header for term assignment. */ +export interface AtlasTermAssignmentHeader { + /** The confidence of the term assignment. */ + confidence?: number; + /** The user who created the record. */ + createdBy?: string; + /** The description of the term assignment. */ + description?: string; + /** The display text. */ + displayText?: string; + /** The expression of the term assignment. */ + expression?: string; + /** The GUID of the relationship. */ + relationGuid?: string; + /** + * The status of terms assignment. + * + * Possible values: DISCOVERED, PROPOSED, IMPORTED, VALIDATED, DEPRECATED, OBSOLETE, OTHER + */ + status?: string; + /** The steward of the term. */ + steward?: string; + /** The GUID of the term. */ + termGuid?: string; +} + +/** ContactBasic */ +export interface ContactBasic { + /** Azure Active Directory object Id. */ + id?: string; + /** additional information to describe this contact. */ + info?: string; +} + +/** An instance of an entity - like hive_table, hive_database. */ +export interface AtlasEntityHeader { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of classification names. */ + classificationNames?: string[]; + /** An array of classifications. */ + classifications?: Array; + /** The display text. */ + displayText?: string; + /** The GUID of the record. */ + guid?: string; + /** Whether it is a shell entity */ + isIncomplete?: boolean; + /** labels */ + labels?: string[]; + /** An array of meanings. */ + meaningNames?: string[]; + /** An array of term assignment headers. */ + meanings?: Array; + /** + * Status of the entity - can be active or deleted. Deleted entities are not + * removed. + * + * Possible values: ACTIVE, DELETED + */ + status?: string; +} + +/** + * An instance of an entity along with extended info - like hive_table, + * hive_database. + */ +export interface AtlasEntitiesWithExtInfo { + /** The referred entities. */ + referredEntities?: Record; + /** An array of entities. */ + entities?: Array; +} + +/** The request content for classification association. */ +export interface ClassificationAssociateContent { + /** + * An instance of a classification; it doesn't have an identity, this object + * exists only when associated with an entity. + */ + classification?: AtlasClassification; + /** The GUID of the entity. */ + entityGuids?: string[]; +} + +/** An instance of an entity header map. */ +export interface AtlasEntityHeaders { + /** The description of the guid header map, */ + guidHeaderMap?: Record; +} + +/** MoveEntitiesContent */ +export interface MoveEntitiesContent { + /** An array of entity guids to be moved to target collection. */ + entityGuids?: string[]; +} + +/** The glossary object. */ +export interface AtlasGlossary { + /** The GUID of the object. */ + guid?: string; + /** An array of classifications. */ + classifications?: Array; + /** The long version description. */ + longDescription?: string; + /** The name of the glossary object. */ + name?: string; + /** The qualified name of the glossary object. */ + qualifiedName?: string; + /** The short version of description. */ + shortDescription?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** An array of categories. */ + categories?: Array; + /** The language of the glossary. */ + language?: string; + /** An array of related term headers. */ + terms?: Array; + /** The usage of the glossary. */ + usage?: string; +} + +/** The header of the related category. */ +export interface AtlasRelatedCategoryHeader { + /** The GUID of the category. */ + categoryGuid?: string; + /** The description of the category header. */ + description?: string; + /** The display text. */ + displayText?: string; + /** The GUID of the parent category. */ + parentCategoryGuid?: string; + /** The GUID of the relationship. */ + relationGuid?: string; +} + +/** The header of the related term. */ +export interface AtlasRelatedTermHeader { + /** The description of the related term. */ + description?: string; + /** The display text. */ + displayText?: string; + /** The expression of the term. */ + expression?: string; + /** The GUID of the relationship. */ + relationGuid?: string; + /** + * The status of term relationship. + * + * Possible values: DRAFT, ACTIVE, DEPRECATED, OBSOLETE, OTHER + */ + status?: string; + /** The steward of the term. */ + steward?: string; + /** The GUID of the term. */ + termGuid?: string; +} + +/** The glossary category. */ +export interface AtlasGlossaryCategory { + /** The GUID of the object. */ + guid?: string; + /** An array of classifications. */ + classifications?: Array; + /** The long version description. */ + longDescription?: string; + /** The name of the glossary object. */ + name?: string; + /** The qualified name of the glossary object. */ + qualifiedName?: string; + /** The short version of description. */ + shortDescription?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The glossary header with basic information. */ + anchor?: AtlasGlossaryHeader; + /** An array of children categories. */ + childrenCategories?: Array; + /** The header of the related category. */ + parentCategory?: AtlasRelatedCategoryHeader; + /** An array of related term headers. */ + terms?: Array; +} + +/** The glossary header with basic information. */ +export interface AtlasGlossaryHeader { + /** The display text. */ + displayText?: string; + /** The GUID of the glossary. */ + glossaryGuid?: string; + /** The GUID of the relationship. */ + relationGuid?: string; +} + +/** The glossary term. */ +export interface AtlasGlossaryTerm { + /** The GUID of the object. */ + guid?: string; + /** An array of classifications. */ + classifications?: Array; + /** The long version description. */ + longDescription?: string; + /** The name of the glossary object. */ + name?: string; + /** The qualified name of the glossary object. */ + qualifiedName?: string; + /** The short version of description. */ + shortDescription?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The abbreviation of the term. */ + abbreviation?: string; + /** The name of the template. */ + templateName?: unknown[]; + /** The glossary header with basic information. */ + anchor?: AtlasGlossaryHeader; + /** An array of related term headers as antonyms. */ + antonyms?: Array; + /** + * Status of the AtlasGlossaryTerm + * + * Possible values: Draft, Approved, Alert, Expired + */ + status?: string; + /** The nick name of the term. */ + nickName?: string; + /** The hierarchy information of the term. */ + hierarchyInfo?: Array; + /** An array of resource link for term */ + resources?: Array; + /** The dictionary of contacts for terms. Key could be Expert or Steward. */ + contacts?: Record>; + /** + * The custom attributes of the term, which is map>. + * The + * key of the first layer map is term template name. + */ + attributes?: Record>; + /** An array of related object IDs. */ + assignedEntities?: Array; + /** An array of term categorization headers. */ + categories?: Array; + /** An array of related term headers. */ + classifies?: Array; + /** An array of examples. */ + examples?: string[]; + /** An array of related term headers indicating the is-a relationship. */ + isA?: Array; + /** An array of preferred related term headers. */ + preferredTerms?: Array; + /** An array of related term headers that are preferred to. */ + preferredToTerms?: Array; + /** An array of related term headers that are replaced by. */ + replacedBy?: Array; + /** An array of related term headers for replacement. */ + replacementTerms?: Array; + /** An array of related term headers for see also. */ + seeAlso?: Array; + /** An array of related term headers as synonyms. */ + synonyms?: Array; + /** An array of translated related term headers. */ + translatedTerms?: Array; + /** An array of related term headers for translation. */ + translationTerms?: Array; + /** The usage of the term. */ + usage?: string; + /** An array of related term headers as valid values. */ + validValues?: Array; + /** An array of related term headers as valid values for other records. */ + validValuesFor?: Array; +} + +/** PurviewObjectId */ +export interface PurviewObjectId { + /** The GUID of the object. */ + guid?: string; + /** The name of the type. */ + typeName?: string; + /** The unique attributes of the object. */ + uniqueAttributes?: Record; + /** Name */ + name?: string; + /** Display text */ + displayText?: string; + /** Item path */ + itemPath?: string; + /** Resource Id */ + resourceId?: string; + /** Dictionary of */ + properties?: Record; +} + +/** ResourceLink */ +export interface ResourceLink { + /** Display name for url. */ + displayName?: string; + /** web url. http or https */ + url?: string; +} + +/** + * Reference to an object-instance of AtlasEntity type used in relationship + * attribute values + */ +export interface AtlasRelatedObjectId { + /** The GUID of the object. */ + guid?: string; + /** The name of the type. */ + typeName?: string; + /** The unique attributes of the object. */ + uniqueAttributes?: Record; + /** The display text. */ + displayText?: string; + /** + * Status of the entity - can be active or deleted. Deleted entities are not + * removed. + * + * Possible values: ACTIVE, DELETED + */ + entityStatus?: string; + /** Relationship type */ + relationshipType?: string; + /** + * Captures details of struct contents. Not instantiated directly, used only via + * AtlasEntity, AtlasClassification. + */ + relationshipAttributes?: AtlasStruct; + /** The GUID of the relationship. */ + relationshipGuid?: string; + /** + * The enum of relationship status. + * + * Possible values: ACTIVE, DELETED + */ + relationshipStatus?: string; +} + +/** + * Captures details of struct contents. Not instantiated directly, used only via + * AtlasEntity, AtlasClassification. + */ +export interface AtlasStruct { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; +} + +/** The basic information for term categorization. */ +export interface AtlasTermCategorizationHeader { + /** The GUID of the category. */ + categoryGuid?: string; + /** The description of the record. */ + description?: string; + /** The display text. */ + displayText?: string; + /** The GUID of the relationship. */ + relationGuid?: string; + /** + * The status of term relationship. + * + * Possible values: DRAFT, ACTIVE, DEPRECATED, OBSOLETE, OTHER + */ + status?: string; +} + +/** The search query of advanced search request. */ +export interface SearchContent { + /** The keywords applied to all searchable fields. */ + keywords?: string; + /** + * The limit of the number of the search result. default value is 50; maximum + * value is 1000. + */ + limit?: number; + /** + * The token used to get next batch of data. Default 'Null' to get the first + * batch, and will return new token in each response unless there's no more data. + */ + continuationToken?: string; + /** The sort order of search results, can specify multiple fields. */ + orderby?: unknown[]; + /** The filter for the search. See examples for the usage of supported filters. */ + filter?: unknown; + /** The facets for search. See examples for the usage of supported facets. */ + facets?: Array; + /** The taxonomy setting for search. */ + taxonomySetting?: SearchRequestTaxonomySetting; +} + +/** The content of a search facet result item. */ +export interface SearchFacetItem { + /** The count of the facet item. */ + count?: number; + /** The name of the facet item. */ + facet?: string; + /** Define the sorting criteria for items */ + sort?: SearchFacetSort; +} + +/** The sorting criteria */ +export interface SearchFacetSort { + /** + * Order by count + * + * Possible values: asc, desc + */ + count?: string; + /** + * Order by value + * + * Possible values: asc, desc + */ + value?: string; +} + +/** Taxonomy setting for search request */ +export interface SearchRequestTaxonomySetting { + /** Asset types */ + assetTypes?: string[]; + /** The content of a search facet result item. */ + facet?: SearchFacetItem; +} + +/** The query of suggest request. */ +export interface SuggestContent { + /** + * The keywords applied to all fields that support suggest operation. It must be + * at least 1 character, and no more than 100 characters. In the index schema we + * defined a default suggester which lists all the supported fields and specifies + * a search mode. + */ + keywords?: string; + /** + * The number of suggestions we hope to return. The default value is 5. The value + * must be a number between 1 and 100. + */ + limit?: number; + /** The filter for the search. */ + filter?: SearchFilter; +} + +/** Base model for search filter */ +export interface SearchFilterParent { + kind: string; +} + +/** And filter for search */ +export interface AndFilter extends SearchFilterParent { + /** And filter for search */ + kind: "AndFilter"; + /** List of filters */ + and: Array; +} + +/** Not filter for search */ +export interface NotFilter extends SearchFilterParent { + /** Not filter for search */ + kind: "NotFilter"; + /** Not filter */ + not: SearchFilter; +} + +/** Or filter for search */ +export interface OrFilter extends SearchFilterParent { + /** Or filter for search */ + kind: "OrFilter"; + /** List of filters */ + or: Array; +} + +/** Asset type filter for search */ +export interface AssetTypeFilter extends SearchFilterParent { + /** Asset type filter for search */ + kind: "AssetTypeFilter"; + /** Asset type name */ + assetType: string; +} + +/** Attribute filter for search */ +export interface AttributeFilter extends SearchFilterParent { + /** Attribute filter for search */ + kind: "AttributeFilter"; + /** Attribute name */ + attributeName: string; + /** + * Operator + * + * Possible values: eq, ne, gt, lt, ge, le, contains, startswith, prefix, timerange, exists + */ + operator: string; + /** Attribute value */ + attributeValue: unknown; +} + +/** Classification type filter for search */ +export interface ClassificationFilter extends SearchFilterParent { + /** Classification type filter for search */ + kind: "ClassificationFilter"; + /** Classification name */ + classification: string; + /** Whether to include sub classifications */ + includeSubClassifications?: boolean; +} + +/** Classification category filter for search */ +export interface ClassificationCategoryFilter extends SearchFilterParent { + /** Classification category filter for search */ + kind: "ClassificationCategoryFilter"; + /** Classification category */ + classificationCategory: string; +} + +/** Collection id filter for search */ +export interface CollectionIdFilter extends SearchFilterParent { + /** Collection id filter for search */ + kind: "CollectionIdFilter"; + /** Collection id */ + collectionId: string; +} + +/** Contact filter for search */ +export interface ContactFilter extends SearchFilterParent { + /** Contact filter for search */ + kind: "ContactFilter"; + /** Contact type */ + contactType?: string; + /** Contact Id */ + contactId?: string; +} + +/** Domain id filter for search */ +export interface DomainIdFilter extends SearchFilterParent { + /** Domain id filter for search */ + kind: "DomainIdFilter"; + /** Domain id */ + domainId: string; +} + +/** Exists filter for search */ +export interface ExistsFilter extends SearchFilterParent { + /** Exists filter for search */ + kind: "ExistsFilter"; + /** Field */ + exists: string; +} + +/** File extension filter for search */ +export interface FileExtensionFilter extends SearchFilterParent { + /** File extension filter for search */ + kind: "FileExtensionFilter"; + /** File extension */ + fileExtension: string; +} + +/** Label filter for search */ +export interface LabelFilter extends SearchFilterParent { + /** Label filter for search */ + kind: "LabelFilter"; + /** Label */ + label: string; + /** Whether to include sub labels */ + includeSubLabels?: boolean; +} + +/** Label filter for search */ +export interface ObjectTypeFilter extends SearchFilterParent { + /** Label filter for search */ + kind: "ObjectTypeFilter"; + /** Object type */ + objectType: string; +} + +/** Path filter for search */ +export interface PathFilter extends SearchFilterParent { + /** Path filter for search */ + kind: "PathFilter"; + /** Path */ + path: string; + /** Whether the path is parent path */ + isParent?: boolean; +} + +/** Scan info filter for search */ +export interface ScanInfoFilter extends SearchFilterParent { + /** Scan info filter for search */ + kind: "ScanInfoFilter"; + /** Data source name */ + dataSourceName?: string; + /** Scan name */ + scanName?: string; +} + +/** Glossary filter for search */ +export interface GlossaryFilter extends SearchFilterParent { + /** Glossary filter for search */ + kind: "GlossaryFilter"; + /** Glossary type. Either AtlasGlossary or AtlasGlossaryType */ + glossaryType: string; +} + +/** Glossary term filter for search */ +export interface TermFilter extends SearchFilterParent { + /** Term filter for search */ + kind: "TermFilter"; + /** Glossary name */ + glossary?: string; + /** Term name */ + term?: string; + /** Term name */ + termGuid?: string; +} + +/** Id filter for search */ +export interface IdFilter extends SearchFilterParent { + /** Id filter for search */ + kind: "IdFilter"; + /** Id value */ + id: string; +} + +/** Entity type filter for search */ +export interface EntityTypeFilter extends SearchFilterParent { + /** Type filter for search */ + kind: "EntityTypeFilter"; + /** Type name */ + entityType: string; + /** Whether to include sub types */ + includeSubTypes?: boolean; +} + +/** Create time filter for search */ +export interface CreateTimeFilter extends SearchFilterParent { + /** Create time filter for search */ + kind: "CreateTimeFilter"; + /** + * Either using a string 'LAST_24H|LAST_7D|LAST_30D|LAST_365D|MORE_THAN_365D', or using a map for example + * { + * "operator": "lt", + * "timeThreshold": 1545580800000 + * } + * to represent the time filter, operator must be one of gt/lt/gte/lte + */ + createTime: unknown; +} + +/** Update time filter for search */ +export interface UpdateTimeFilter extends SearchFilterParent { + /** Update time filter for search */ + kind: "UpdateTimeFilter"; + /** + * Either using a string 'LAST_24H|LAST_7D|LAST_30D|LAST_365D|MORE_THAN_365D', or using a map for example + * { + * "operator": "lt", + * "timeThreshold": 1545580800000 + * } + * to represent the time filter, operator must be one of gt/lt/gte/lte + */ + updateTime: unknown; +} + +/** The query of autocomplete request. */ +export interface AutoCompleteContent { + /** + * The keywords applied to all fields that support autocomplete operation. It must + * be at least 1 character, and no more than 100 characters. + */ + keywords?: string; + /** + * The number of autocomplete results we hope to return. The default value is 50. + * The value must be a number between 1 and 100. + */ + limit?: number; + /** The filter for the autocomplete request. */ + filter?: SearchFilter; +} + +/** Atlas relationship instance. */ +export interface AtlasRelationship { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** Reference to an object-instance of a type - like entity. */ + end1?: AtlasObjectId; + /** Reference to an object-instance of a type - like entity. */ + end2?: AtlasObjectId; + /** The GUID of the relationship. */ + guid?: string; + /** The home ID of the relationship. */ + homeId?: string; + /** The label of the relationship. */ + label?: string; + /** Used to record the provenance of an instance of an entity or relationship */ + provenanceType?: number; + /** + * The enum of relationship status. + * + * Possible values: ACTIVE, DELETED + */ + status?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the relationship. */ + version?: number; +} + +/** Reference to an object-instance of a type - like entity. */ +export interface AtlasObjectId { + /** The GUID of the object. */ + guid?: string; + /** The name of the type. */ + typeName?: string; + /** The unique attributes of the object. */ + uniqueAttributes?: Record; +} + +/** class that captures details of a struct-type. */ +export interface AtlasBusinessMetadataDef { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormat; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; +} + +/** The date format. */ +export interface DateFormat { + /** An array of available locales. */ + availableLocales?: string[]; + /** Calendar */ + calendar?: number; + /** The date format. */ + dateInstance?: DateFormat; + /** The date format. */ + dateTimeInstance?: DateFormat; + /** The date format. */ + instance?: DateFormat; + /** Determines the leniency of the date format. */ + lenient?: boolean; + /** The number format. */ + numberFormat?: NumberFormat; + /** The date format. */ + timeInstance?: DateFormat; + /** The timezone information. */ + timeZone?: TimeZone; +} + +/** The number format. */ +export interface NumberFormat { + /** The number format. */ + availableLocales?: string[]; + /** The currency. */ + currency?: string; + /** The number format. */ + currencyInstance?: NumberFormat; + /** Determines if grouping is used. */ + groupingUsed?: boolean; + /** The number format. */ + instance?: NumberFormat; + /** The number format. */ + integerInstance?: NumberFormat; + /** The maximum of fraction digits. */ + maximumFractionDigits?: number; + /** The maximum of integer digits. */ + maximumIntegerDigits?: number; + /** The minimum of fraction digits. */ + minimumFractionDigits?: number; + /** The minimum of integer digits. */ + minimumIntegerDigits?: number; + /** The number format. */ + numberInstance?: NumberFormat; + /** Determines if only integer is parsed. */ + parseIntegerOnly?: boolean; + /** The number format. */ + percentInstance?: NumberFormat; + /** + * The enum of rounding mode. + * + * Possible values: UP, DOWN, CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UNNECESSARY + */ + roundingMode?: string; +} + +/** The timezone information. */ +export interface TimeZone { + /** The value of the daylight saving time. */ + dstSavings?: number; + /** The ID of the timezone. */ + id?: string; + /** An array of available IDs. */ + availableIds?: string[]; + /** The timezone information. */ + default?: TimeZone; + /** The display name of the timezone. */ + displayName?: string; + /** The raw offset of the timezone. */ + rawOffset?: number; +} + +/** class that captures details of a struct-attribute. */ +export interface AtlasAttributeDef { + /** + * single-valued attribute or multi-valued attribute. + * + * Possible values: SINGLE, LIST, SET + */ + cardinality?: string; + /** An array of constraints. */ + constraints?: Array; + /** The default value of the attribute. */ + defaultValue?: string; + /** The description of the attribute. */ + description?: string; + /** Determines if it is included in notification. */ + includeInNotification?: boolean; + /** Determines if it is indexable. */ + isIndexable?: boolean; + /** Determines if it is optional. */ + isOptional?: boolean; + /** Determines if it unique. */ + isUnique?: boolean; + /** The name of the attribute. */ + name?: string; + /** The options for the attribute. */ + options?: Record; + /** The name of the type. */ + typeName?: string; + /** The maximum count of the values. */ + valuesMaxCount?: number; + /** The minimum count of the values. */ + valuesMinCount?: number; +} + +/** class that captures details of a constraint. */ +export interface AtlasConstraintDef { + /** The parameters of the constraint definition. */ + params?: Record; + /** The type of the constraint. */ + type?: string; +} + +/** class that captures details of a classification-type. */ +export interface AtlasClassificationDef { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormat; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; + /** + * Specifying a list of entityType names in the classificationDef, ensures that + * classifications can + * only be applied to those entityTypes. + * + * Any subtypes of the entity types inherit the restriction. + * + * Any classificationDef subtypes inherit the parents entityTypes restrictions. + * + * Any classificationDef subtypes can further restrict the parents entityTypes + * restrictions by specifying a subset of the entityTypes. + * + * An empty entityTypes list when there are no parent restrictions means there are no + * restrictions. + * + * An empty entityTypes list when there are parent + * restrictions means that the subtype picks up the parents + * restrictions. + * + * If a list of entityTypes are supplied, where one inherits + * from another, this will be rejected. This should encourage cleaner + * classificationsDefs. + * + */ + entityTypes?: string[]; + /** An array of sub types. */ + subTypes?: string[]; + /** An array of super types. */ + superTypes?: string[]; +} + +/** class that captures details of a entity-type. */ +export interface AtlasEntityDef { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormat; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; + /** An array of sub types. */ + subTypes?: string[]; + /** An array of super types. */ + superTypes?: string[]; + /** An array of relationship attributes. */ + relationshipAttributeDefs?: Array; +} + +/** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ +export interface AtlasRelationshipAttributeDef { + /** + * single-valued attribute or multi-valued attribute. + * + * Possible values: SINGLE, LIST, SET + */ + cardinality?: string; + /** An array of constraints. */ + constraints?: Array; + /** The default value of the attribute. */ + defaultValue?: string; + /** The description of the attribute. */ + description?: string; + /** Determines if it is included in notification. */ + includeInNotification?: boolean; + /** Determines if it is indexable. */ + isIndexable?: boolean; + /** Determines if it is optional. */ + isOptional?: boolean; + /** Determines if it unique. */ + isUnique?: boolean; + /** The name of the attribute. */ + name?: string; + /** The options for the attribute. */ + options?: Record; + /** The name of the type. */ + typeName?: string; + /** The maximum count of the values. */ + valuesMaxCount?: number; + /** The minimum count of the values. */ + valuesMinCount?: number; + /** Determines if it is a legacy attribute. */ + isLegacyAttribute?: boolean; + /** The name of the relationship type. */ + relationshipTypeName?: string; +} + +/** class that captures details of an enum-type. */ +export interface AtlasEnumDef { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormat; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The default value. */ + defaultValue?: string; + /** An array of enum element definitions. */ + elementDefs?: Array; +} + +/** class that captures details of an enum-element. */ +export interface AtlasEnumElementDef { + /** The description of the enum element definition. */ + description?: string; + /** The ordinal of the enum element definition. */ + ordinal?: number; + /** The value of the enum element definition. */ + value?: string; +} + +/** + * AtlasRelationshipDef is a TypeDef that defines a relationship. + * As with other typeDefs the AtlasRelationshipDef has a name. Once created the + * RelationshipDef has a guid. + * The name and the guid are the 2 ways that the + * RelationshipDef is identified. + * RelationshipDefs have 2 ends, each of which + * specify cardinality, an EntityDef type name and name and optionally + * whether the + * end is a container. + * RelationshipDefs can have AttributeDefs - though only + * primitive types are allowed. + * RelationshipDefs have a relationshipCategory + * specifying the UML type of relationship required + * The way EntityDefs and + * RelationshipDefs are intended to be used is that EntityDefs will define + * AttributeDefs these AttributeDefs + * will not specify an EntityDef type name as + * their types. + * RelationshipDefs introduce new attributes to the entity + * instances. For example + * EntityDef A might have attributes attr1,attr2,attr3 + * + * EntityDef B might have attributes attr4,attr5,attr6 + * RelationshipDef + * AtoB might define 2 ends + * + * end1: type A, name attr7 + * end2: type B, name attr8 + * + * When an instance of EntityDef A is created, it + * will have attributes attr1,attr2,attr3,attr7 + * When an instance of EntityDef + * B is created, it will have attributes attr4,attr5,attr6,attr8 + * + * In this way + * relationshipDefs can be authored separately from entityDefs and can inject + * relationship attributes into + * the entity instances + */ +export interface AtlasRelationshipDef { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormat; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; + /** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ + endDef1?: AtlasRelationshipEndDef; + /** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ + endDef2?: AtlasRelationshipEndDef; + /** + * The Relationship category determines the style of relationship around + * containment and lifecycle. + * UML terminology is used for the values. + * ASSOCIATION is a relationship with no containment. + * COMPOSITION and AGGREGATION are containment relationships. + * The difference being in the lifecycles of the container and its children. + * In the COMPOSITION case, the children cannot exist without the container. + * For AGGREGATION, the life cycles of the container and children are totally independent. + * + * Possible values: ASSOCIATION, AGGREGATION, COMPOSITION + */ + relationshipCategory?: string; + /** The label of the relationship. */ + relationshipLabel?: string; +} + +/** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ +export interface AtlasRelationshipEndDef { + /** + * single-valued attribute or multi-valued attribute. + * + * Possible values: SINGLE, LIST, SET + */ + cardinality?: string; + /** The description of the relationship end definition. */ + description?: string; + /** Determines if it is container. */ + isContainer?: boolean; + /** Determines if it is a legacy attribute. */ + isLegacyAttribute?: boolean; + /** The name of the relationship end definition. */ + name?: string; + /** The type of the relationship end. */ + type?: string; +} + +/** class that captures details of a struct-type. */ +export interface AtlasStructDef { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormat; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; +} + +/** The definitions of types. */ +export interface AtlasTypesDef { + /** businessMetadataDefs */ + businessMetadataDefs?: Array; + /** An array of classification definitions. */ + classificationDefs?: Array; + /** An array of entity definitions. */ + entityDefs?: Array; + /** An array of enum definitions. */ + enumDefs?: Array; + /** An array of relationship definitions. */ + relationshipDefs?: Array; + /** An array of struct definitions. */ + structDefs?: Array; + /** An array of term template definitions. */ + termTemplateDefs?: Array; +} + +/** Term template definition for glossary term. */ +export interface TermTemplateDef { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormat; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; +} + +/** Base model for search filter */ +export type SearchFilter = + | AndFilter + | NotFilter + | OrFilter + | AssetTypeFilter + | AttributeFilter + | ClassificationFilter + | ClassificationCategoryFilter + | CollectionIdFilter + | ContactFilter + | DomainIdFilter + | ExistsFilter + | FileExtensionFilter + | LabelFilter + | ObjectTypeFilter + | PathFilter + | ScanInfoFilter + | GlossaryFilter + | TermFilter + | IdFilter + | EntityTypeFilter + | CreateTimeFilter + | UpdateTimeFilter; diff --git a/sdk/purview/purview-datamap-rest/src/outputModels.ts b/sdk/purview/purview-datamap-rest/src/outputModels.ts new file mode 100644 index 000000000000..0cf2dbb70462 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/outputModels.ts @@ -0,0 +1,1622 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +/** + * An instance of an entity along with extended info - like hive_table, + * hive_database. + */ +export interface AtlasEntityWithExtInfoOutput { + /** The referred entities. */ + referredEntities?: Record; + /** An instance of an entity - like hive_table, hive_database. */ + entity?: AtlasEntityOutput; +} + +/** An instance of an entity - like hive_table, hive_database. */ +export interface AtlasEntityOutput { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** Business attributes */ + businessAttributes?: Record; + /** An array of classifications. */ + classifications?: Array; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** Custom Attribute */ + customAttributes?: Record; + /** The GUID of the entity. */ + guid?: string; + /** The home ID of the entity. */ + homeId?: string; + /** The collection ID of the entity. */ + readonly collectionId?: string; + /** Whether it is a shell entity */ + isIncomplete?: boolean; + /** labels */ + labels?: string[]; + /** An array of term assignment headers indicating the meanings of the entity. */ + meanings?: Array; + /** Used to record the provenance of an instance of an entity or relationship. */ + provenanceType?: number; + /** Determines if there's a proxy. */ + proxy?: boolean; + /** The attributes of relationship. */ + relationshipAttributes?: Record; + /** + * Status of the entity - can be active or deleted. Deleted entities are not + * removed. + * + * Possible values: ACTIVE, DELETED + */ + status?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the entity. */ + version?: number; + /** The dictionary of contacts for entities. Key could be Expert or Owner. */ + contacts?: Record>; +} + +/** + * An instance of a classification; it doesn't have an identity, this object + * exists only when associated with an entity. + */ +export interface AtlasClassificationOutput { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The GUID of the entity. */ + entityGuid?: string; + /** + * Status of the entity - can be active or deleted. Deleted entities are not + * removed. + * + * Possible values: ACTIVE, DELETED + */ + entityStatus?: string; + /** Determines if propagations will be removed on entity deletion. */ + removePropagationsOnEntityDelete?: boolean; + /** An array of time boundaries indicating validity periods. */ + validityPeriods?: Array; +} + +/** Captures time-boundary details */ +export interface TimeBoundaryOutput { + /** The end of the time boundary. */ + endTime?: string; + /** The start of the time boundary. */ + startTime?: string; + /** The timezone of the time boundary. */ + timeZone?: string; +} + +/** The header for term assignment. */ +export interface AtlasTermAssignmentHeaderOutput { + /** The confidence of the term assignment. */ + confidence?: number; + /** The user who created the record. */ + createdBy?: string; + /** The description of the term assignment. */ + description?: string; + /** The display text. */ + displayText?: string; + /** The expression of the term assignment. */ + expression?: string; + /** The GUID of the relationship. */ + relationGuid?: string; + /** + * The status of terms assignment. + * + * Possible values: DISCOVERED, PROPOSED, IMPORTED, VALIDATED, DEPRECATED, OBSOLETE, OTHER + */ + status?: string; + /** The steward of the term. */ + steward?: string; + /** The GUID of the term. */ + termGuid?: string; +} + +/** ContactBasic */ +export interface ContactBasicOutput { + /** Azure Active Directory object Id. */ + id?: string; + /** additional information to describe this contact. */ + info?: string; +} + +/** The mutation response result of entity. */ +export interface EntityMutationResultOutput { + /** A map of GUID assignments with entities. */ + guidAssignments?: Record; + /** The entity headers of mutated entities. */ + mutatedEntities?: Record>; + /** An array of entity headers that partially updated. */ + partialUpdatedEntities?: Array; +} + +/** An instance of an entity - like hive_table, hive_database. */ +export interface AtlasEntityHeaderOutput { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of classification names. */ + classificationNames?: string[]; + /** An array of classifications. */ + classifications?: Array; + /** The display text. */ + displayText?: string; + /** The GUID of the record. */ + guid?: string; + /** Whether it is a shell entity */ + isIncomplete?: boolean; + /** labels */ + labels?: string[]; + /** An array of meanings. */ + meaningNames?: string[]; + /** An array of term assignment headers. */ + meanings?: Array; + /** + * Status of the entity - can be active or deleted. Deleted entities are not + * removed. + * + * Possible values: ACTIVE, DELETED + */ + status?: string; +} + +/** An error response from the service */ +export interface AtlasErrorResponseOutput { + /** The request ID. */ + requestId?: string; + /** The error code. */ + errorCode?: string; + /** The error message. */ + errorMessage?: string; +} + +/** + * An instance of an entity along with extended info - like hive_table, + * hive_database. + */ +export interface AtlasEntitiesWithExtInfoOutput { + /** The referred entities. */ + referredEntities?: Record; + /** An array of entities. */ + entities?: Array; +} + +/** REST serialization friendly list. */ +export interface AtlasClassificationsOutput { + /** An array of objects. */ + list?: any[]; + /** The size of the page. */ + pageSize?: number; + /** The sorted by field. */ + sortBy?: string; + /** + * to specify whether the result should be sorted? If yes, whether asc or desc. + * + * Possible values: NONE, ASC, DESC + */ + sortType?: string; + /** The start index of the page. */ + startIndex?: number; + /** The total count of items. */ + totalCount?: number; +} + +/** Bulk import result */ +export interface BulkImportResultOutput { + /** failed importInfoList */ + failedImportInfoList?: Array; + /** successful importInfoList */ + successImportInfoList?: Array; +} + +/** ImportInfo */ +export interface ImportInfoOutput { + /** childObjectName */ + childObjectName?: string; + /** + * importStatus + * + * Possible values: SUCCESS, FAILED + */ + importStatus?: string; + /** parentObjectName */ + parentObjectName?: string; + /** remarks */ + remarks?: string; +} + +/** The glossary object. */ +export interface AtlasGlossaryOutput { + /** The GUID of the object. */ + guid?: string; + /** An array of classifications. */ + classifications?: Array; + /** The long version description. */ + longDescription?: string; + /** The name of the glossary object. */ + name?: string; + /** The qualified name of the glossary object. */ + qualifiedName?: string; + /** The short version of description. */ + shortDescription?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** An array of categories. */ + categories?: Array; + /** The language of the glossary. */ + language?: string; + /** An array of related term headers. */ + terms?: Array; + /** The usage of the glossary. */ + usage?: string; +} + +/** The header of the related category. */ +export interface AtlasRelatedCategoryHeaderOutput { + /** The GUID of the category. */ + categoryGuid?: string; + /** The description of the category header. */ + description?: string; + /** The display text. */ + displayText?: string; + /** The GUID of the parent category. */ + parentCategoryGuid?: string; + /** The GUID of the relationship. */ + relationGuid?: string; +} + +/** The header of the related term. */ +export interface AtlasRelatedTermHeaderOutput { + /** The description of the related term. */ + description?: string; + /** The display text. */ + displayText?: string; + /** The expression of the term. */ + expression?: string; + /** The GUID of the relationship. */ + relationGuid?: string; + /** + * The status of term relationship. + * + * Possible values: DRAFT, ACTIVE, DEPRECATED, OBSOLETE, OTHER + */ + status?: string; + /** The steward of the term. */ + steward?: string; + /** The GUID of the term. */ + termGuid?: string; +} + +/** The glossary category. */ +export interface AtlasGlossaryCategoryOutput { + /** The GUID of the object. */ + guid?: string; + /** An array of classifications. */ + classifications?: Array; + /** The long version description. */ + longDescription?: string; + /** The name of the glossary object. */ + name?: string; + /** The qualified name of the glossary object. */ + qualifiedName?: string; + /** The short version of description. */ + shortDescription?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The glossary header with basic information. */ + anchor?: AtlasGlossaryHeaderOutput; + /** An array of children categories. */ + childrenCategories?: Array; + /** The header of the related category. */ + parentCategory?: AtlasRelatedCategoryHeaderOutput; + /** An array of related term headers. */ + terms?: Array; +} + +/** The glossary header with basic information. */ +export interface AtlasGlossaryHeaderOutput { + /** The display text. */ + displayText?: string; + /** The GUID of the glossary. */ + glossaryGuid?: string; + /** The GUID of the relationship. */ + relationGuid?: string; +} + +/** The glossary term. */ +export interface AtlasGlossaryTermOutput { + /** The GUID of the object. */ + guid?: string; + /** An array of classifications. */ + classifications?: Array; + /** The long version description. */ + longDescription?: string; + /** The name of the glossary object. */ + name?: string; + /** The qualified name of the glossary object. */ + qualifiedName?: string; + /** The short version of description. */ + shortDescription?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The abbreviation of the term. */ + abbreviation?: string; + /** The name of the template. */ + templateName?: any[]; + /** The glossary header with basic information. */ + anchor?: AtlasGlossaryHeaderOutput; + /** An array of related term headers as antonyms. */ + antonyms?: Array; + /** + * Status of the AtlasGlossaryTerm + * + * Possible values: Draft, Approved, Alert, Expired + */ + status?: string; + /** The nick name of the term. */ + nickName?: string; + /** The hierarchy information of the term. */ + hierarchyInfo?: Array; + /** An array of resource link for term */ + resources?: Array; + /** The dictionary of contacts for terms. Key could be Expert or Steward. */ + contacts?: Record>; + /** + * The custom attributes of the term, which is map>. + * The + * key of the first layer map is term template name. + */ + attributes?: Record>; + /** An array of related object IDs. */ + assignedEntities?: Array; + /** An array of term categorization headers. */ + categories?: Array; + /** An array of related term headers. */ + classifies?: Array; + /** An array of examples. */ + examples?: string[]; + /** An array of related term headers indicating the is-a relationship. */ + isA?: Array; + /** An array of preferred related term headers. */ + preferredTerms?: Array; + /** An array of related term headers that are preferred to. */ + preferredToTerms?: Array; + /** An array of related term headers that are replaced by. */ + replacedBy?: Array; + /** An array of related term headers for replacement. */ + replacementTerms?: Array; + /** An array of related term headers for see also. */ + seeAlso?: Array; + /** An array of related term headers as synonyms. */ + synonyms?: Array; + /** An array of translated related term headers. */ + translatedTerms?: Array; + /** An array of related term headers for translation. */ + translationTerms?: Array; + /** The usage of the term. */ + usage?: string; + /** An array of related term headers as valid values. */ + validValues?: Array; + /** An array of related term headers as valid values for other records. */ + validValuesFor?: Array; +} + +/** PurviewObjectId */ +export interface PurviewObjectIdOutput { + /** The GUID of the object. */ + guid?: string; + /** The name of the type. */ + typeName?: string; + /** The unique attributes of the object. */ + uniqueAttributes?: Record; + /** Name */ + name?: string; + /** Display text */ + displayText?: string; + /** Item path */ + itemPath?: string; + /** Resource Id */ + resourceId?: string; + /** Dictionary of */ + properties?: Record; +} + +/** ResourceLink */ +export interface ResourceLinkOutput { + /** Display name for url. */ + displayName?: string; + /** web url. http or https */ + url?: string; +} + +/** + * Reference to an object-instance of AtlasEntity type used in relationship + * attribute values + */ +export interface AtlasRelatedObjectIdOutput { + /** The GUID of the object. */ + guid?: string; + /** The name of the type. */ + typeName?: string; + /** The unique attributes of the object. */ + uniqueAttributes?: Record; + /** The display text. */ + displayText?: string; + /** + * Status of the entity - can be active or deleted. Deleted entities are not + * removed. + * + * Possible values: ACTIVE, DELETED + */ + entityStatus?: string; + /** Relationship type */ + relationshipType?: string; + /** + * Captures details of struct contents. Not instantiated directly, used only via + * AtlasEntity, AtlasClassification. + */ + relationshipAttributes?: AtlasStructOutput; + /** The GUID of the relationship. */ + relationshipGuid?: string; + /** + * The enum of relationship status. + * + * Possible values: ACTIVE, DELETED + */ + relationshipStatus?: string; +} + +/** + * Captures details of struct contents. Not instantiated directly, used only via + * AtlasEntity, AtlasClassification. + */ +export interface AtlasStructOutput { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; +} + +/** The basic information for term categorization. */ +export interface AtlasTermCategorizationHeaderOutput { + /** The GUID of the category. */ + categoryGuid?: string; + /** The description of the record. */ + description?: string; + /** The display text. */ + displayText?: string; + /** The GUID of the relationship. */ + relationGuid?: string; + /** + * The status of term relationship. + * + * Possible values: DRAFT, ACTIVE, DEPRECATED, OBSOLETE, OTHER + */ + status?: string; +} + +/** The extended information of glossary. */ +export interface AtlasGlossaryExtInfoOutput { + /** The GUID of the object. */ + guid?: string; + /** An array of classifications. */ + classifications?: Array; + /** The long version description. */ + longDescription?: string; + /** The name of the glossary object. */ + name?: string; + /** The qualified name of the glossary object. */ + qualifiedName?: string; + /** The short version of description. */ + shortDescription?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** An array of categories. */ + categories?: Array; + /** The language of the glossary. */ + language?: string; + /** An array of related term headers. */ + terms?: Array; + /** The usage of the glossary. */ + usage?: string; + /** The glossary category information. */ + categoryInfo?: Record; + /** The glossary term information. */ + termInfo?: Record; +} + +/** The result of the search result. */ +export interface SearchResultOutput { + /** + * The total number of search results (not the number of documents in a single + * page). + */ + "@search.count"?: number; + /** 'True' if the '@search.count' is an approximate value and vise versa. */ + "@search.count.approximate"?: boolean; + /** The token used to get next batch of data. Absent if there's no more data. */ + continuationToken?: string; + /** + * A facet list that consists of index fields assetType ,classification, + * contactId, and label. When the facet is specified in the request, the value of + * the facet is returned as an element of @search.facets. + */ + "@search.facets"?: SearchFacetResultValueOutput; + /** Search result value */ + value?: Array; +} + +/** + * A facet list that consists of index fields assetType ,classification, + * contactId, and label. When the facet is specified in the request, the value of + * the facet is returned as an element of @search.facets. + */ +export interface SearchFacetResultValueOutput { + /** Entity type */ + entityType?: Array; + /** Asset type */ + assetType?: Array; + /** Classification */ + classification?: Array; + /** Term */ + term?: Array; + /** Contact id */ + contactId?: Array; + /** Contact type */ + contactType?: Array; + /** Label */ + label?: Array; + /** Glossary type */ + glossaryType?: Array; + /** Term status */ + termStatus?: Array; + /** Term template */ + termTemplate?: Array; +} + +/** The content of a search facet result item. */ +export interface SearchFacetItemValueOutput { + /** The count of the facet item. */ + count?: number; + /** The name of the facet item. */ + value?: string; +} + +/** The value item of the search result. */ +export interface SearchResultValueOutput { + /** + * The search score calculated by the search engine. The results are ordered by + * search score by default. + */ + "@search.score"?: number; + /** + * A highlight list that consists of index fields id ,qualifiedName, name, + * description, entityType. When the keyword appears in those fields, the value of + * the field, attached with emphasis mark, is returned as an element of + * @search.highlights. + */ + "@search.highlights"?: SearchHighlightsOutput; + /** + * The object type of the record. Object type is the top-level property to + * distinguish whether a record is an asset or a term. + */ + objectType?: string; + /** The create time of the record. The Unix epoch format. */ + createTime?: number; + /** The last update time of the record. The Unix epoch format. */ + updateTime?: number; + /** The GUID of the record. */ + id?: string; + /** The name of the record. */ + name?: string; + /** The qualified name of the record. */ + qualifiedName?: string; + /** The type name of the asset. */ + entityType?: string; + /** The description of the asset. */ + description?: string; + /** The endorsement of the asset. */ + endorsement?: string; + /** The owner of the record. */ + owner?: string; + /** The classifications of the record. */ + classification?: string[]; + /** The labels of the asset. */ + label?: string[]; + /** The terms assigned to the asset. */ + term?: Array; + /** The contacts of the asset. */ + contact?: Array; + /** The asset types of the asset. */ + assetType?: string[]; + /** + * The type name of the term. Could be AtlasGlossary, AtlasGlossaryTerm or + * AtlasGlossaryCategory. + */ + glossaryType?: string; + /** The glossary name of the term. */ + glossary?: string; + /** The status of the term. */ + termStatus?: string; + /** The term template names used by the term. */ + termTemplate?: string[]; + /** The definition of the term. */ + longDescription?: string; +} + +/** + * A highlight list that consists of index fields id ,qualifiedName, name, + * description, entityType. When the keyword appears in those fields, the value of + * the field, attached with emphasis mark, is returned as an element of + * @search.highlights. + */ +export interface SearchHighlightsOutput { + /** Id */ + id?: string[]; + /** Qualified name */ + qualifiedName?: string[]; + /** Name */ + name?: string[]; + /** Description */ + description?: string[]; + /** Entity type */ + entityType?: string[]; +} + +/** The context. */ +export interface TermSearchResultValueOutput { + /** The name of the term. */ + name?: string; + /** The name of the glossary which contains the term. */ + glossaryName?: string; + /** The GUID of the term. */ + guid?: string; +} + +/** The contact in the search and suggest result. */ +export interface ContactSearchResultValueOutput { + /** The GUID of the contact. */ + id?: string; + /** The description of the contact. */ + info?: string; + /** + * The type of the contact. It can be Expert or Owner for an entity. It can be + * Expert or Steward for a glossary term. + */ + contactType?: string; +} + +/** The result item of the search suggest. */ +export interface SuggestResultOutput { + /** The result value */ + value?: Array; +} + +/** The value item of the search suggest. */ +export interface SuggestResultValueOutput { + /** + * The search score calculated by the search engine. The results are ordered by + * search score by default. + */ + "@search.score"?: number; + /** + * The target text that contains the keyword as prefix. The keyword is wrapped + * with emphasis mark. + */ + "@search.text"?: string; + /** + * The object type of the record. Object type is the top-level property to + * distinguish whether a record is an asset or a term. + */ + objectType?: string; + /** The create time of the record. The Unix epoch format. */ + createTime?: number; + /** The last update time of the record. The Unix epoch format. */ + updateTime?: number; + /** The GUID of the record. */ + id?: string; + /** The name of the record. */ + name?: string; + /** The qualified name of the record. */ + qualifiedName?: string; + /** The type name of the asset. */ + entityType?: string; + /** The description of the asset. */ + description?: string; + /** The endorsement of the asset. */ + endorsement?: string; + /** The owner of the record. */ + owner?: string; + /** The classifications of the record. */ + classification?: string[]; + /** The labels of the asset. */ + label?: string[]; + /** The terms assigned to the asset. */ + term?: Array; + /** The contacts of the asset. */ + contact?: Array; + /** The asset types of the asset. */ + assetType?: string[]; + /** + * The type name of the term. Could be AtlasGlossary, AtlasGlossaryTerm or + * AtlasGlossaryCategory. + */ + glossaryType?: string; + /** The glossary name of the term. */ + glossary?: string; + /** The status of the term. */ + termStatus?: string; + /** The term template names used by the term. */ + termTemplate?: string[]; + /** The definition of the term. */ + longDescription?: string; +} + +/** The result of the autocomplete request. */ +export interface AutoCompleteResultOutput { + /** The result value */ + value?: Array; +} + +/** The value item of the autocomplete suggest. */ +export interface AutoCompleteResultValueOutput { + /** The completed term or phrase. */ + text?: string; + /** The completed search query text. */ + queryPlusText?: string; +} + +/** The lineage information. */ +export interface AtlasLineageInfoOutput { + /** The GUID of the base entity. */ + baseEntityGuid?: string; + /** The GUID entity map. */ + guidEntityMap?: Record; + /** The entity count in specific direction. */ + widthCounts?: Record>; + /** The depth of lineage. */ + lineageDepth?: number; + /** The width of lineage. */ + lineageWidth?: number; + /** The number of children node. */ + childrenCount?: number; + /** + * The enum of lineage direction. + * + * Possible values: INPUT, OUTPUT, BOTH + */ + lineageDirection?: string; + /** An array of parentRelations relations. */ + parentRelations?: Array; + /** An array of lineage relations. */ + relations?: Array; +} + +/** The lineage parents relation with GUID of the parent entity and to child entity. */ +export interface ParentRelationOutput { + /** The GUID of child entity. */ + childEntityId?: string; + /** The GUID of relationship. */ + relationshipId?: string; + /** The GUID of parent entity. */ + parentEntityId?: string; +} + +/** The lineage relation with GUID of the from and to entity. */ +export interface LineageRelationOutput { + /** The GUID of from-entity. */ + fromEntityId?: string; + /** The GUID of relationship. */ + relationshipId?: string; + /** The GUID of to-entity. */ + toEntityId?: string; +} + +/** Atlas relationship instance. */ +export interface AtlasRelationshipOutput { + /** The attributes of the struct. */ + attributes?: Record; + /** The name of the type. */ + typeName?: string; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** Reference to an object-instance of a type - like entity. */ + end1?: AtlasObjectIdOutput; + /** Reference to an object-instance of a type - like entity. */ + end2?: AtlasObjectIdOutput; + /** The GUID of the relationship. */ + guid?: string; + /** The home ID of the relationship. */ + homeId?: string; + /** The label of the relationship. */ + label?: string; + /** Used to record the provenance of an instance of an entity or relationship */ + provenanceType?: number; + /** + * The enum of relationship status. + * + * Possible values: ACTIVE, DELETED + */ + status?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the relationship. */ + version?: number; +} + +/** Reference to an object-instance of a type - like entity. */ +export interface AtlasObjectIdOutput { + /** The GUID of the object. */ + guid?: string; + /** The name of the type. */ + typeName?: string; + /** The unique attributes of the object. */ + uniqueAttributes?: Record; +} + +/** The relationship with extended information. */ +export interface AtlasRelationshipWithExtInfoOutput { + /** The referred entity header. */ + referredEntities?: Record; + /** Atlas relationship instance. */ + relationship?: AtlasRelationshipOutput; +} + +/** class that captures details of a struct-type. */ +export interface AtlasBusinessMetadataDefOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormatOutput; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; +} + +/** The date format. */ +export interface DateFormatOutput { + /** An array of available locales. */ + availableLocales?: string[]; + /** Calendar */ + calendar?: number; + /** The date format. */ + dateInstance?: DateFormatOutput; + /** The date format. */ + dateTimeInstance?: DateFormatOutput; + /** The date format. */ + instance?: DateFormatOutput; + /** Determines the leniency of the date format. */ + lenient?: boolean; + /** The number format. */ + numberFormat?: NumberFormatOutput; + /** The date format. */ + timeInstance?: DateFormatOutput; + /** The timezone information. */ + timeZone?: TimeZoneOutput; +} + +/** The number format. */ +export interface NumberFormatOutput { + /** The number format. */ + availableLocales?: string[]; + /** The currency. */ + currency?: string; + /** The number format. */ + currencyInstance?: NumberFormatOutput; + /** Determines if grouping is used. */ + groupingUsed?: boolean; + /** The number format. */ + instance?: NumberFormatOutput; + /** The number format. */ + integerInstance?: NumberFormatOutput; + /** The maximum of fraction digits. */ + maximumFractionDigits?: number; + /** The maximum of integer digits. */ + maximumIntegerDigits?: number; + /** The minimum of fraction digits. */ + minimumFractionDigits?: number; + /** The minimum of integer digits. */ + minimumIntegerDigits?: number; + /** The number format. */ + numberInstance?: NumberFormatOutput; + /** Determines if only integer is parsed. */ + parseIntegerOnly?: boolean; + /** The number format. */ + percentInstance?: NumberFormatOutput; + /** + * The enum of rounding mode. + * + * Possible values: UP, DOWN, CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UNNECESSARY + */ + roundingMode?: string; +} + +/** The timezone information. */ +export interface TimeZoneOutput { + /** The value of the daylight saving time. */ + dstSavings?: number; + /** The ID of the timezone. */ + id?: string; + /** An array of available IDs. */ + availableIds?: string[]; + /** The timezone information. */ + default?: TimeZoneOutput; + /** The display name of the timezone. */ + displayName?: string; + /** The raw offset of the timezone. */ + rawOffset?: number; +} + +/** class that captures details of a struct-attribute. */ +export interface AtlasAttributeDefOutput { + /** + * single-valued attribute or multi-valued attribute. + * + * Possible values: SINGLE, LIST, SET + */ + cardinality?: string; + /** An array of constraints. */ + constraints?: Array; + /** The default value of the attribute. */ + defaultValue?: string; + /** The description of the attribute. */ + description?: string; + /** Determines if it is included in notification. */ + includeInNotification?: boolean; + /** Determines if it is indexable. */ + isIndexable?: boolean; + /** Determines if it is optional. */ + isOptional?: boolean; + /** Determines if it unique. */ + isUnique?: boolean; + /** The name of the attribute. */ + name?: string; + /** The options for the attribute. */ + options?: Record; + /** The name of the type. */ + typeName?: string; + /** The maximum count of the values. */ + valuesMaxCount?: number; + /** The minimum count of the values. */ + valuesMinCount?: number; +} + +/** class that captures details of a constraint. */ +export interface AtlasConstraintDefOutput { + /** The parameters of the constraint definition. */ + params?: Record; + /** The type of the constraint. */ + type?: string; +} + +/** class that captures details of a classification-type. */ +export interface AtlasClassificationDefOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormatOutput; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; + /** + * Specifying a list of entityType names in the classificationDef, ensures that + * classifications can + * only be applied to those entityTypes. + * + * Any subtypes of the entity types inherit the restriction. + * + * Any classificationDef subtypes inherit the parents entityTypes restrictions. + * + * Any classificationDef subtypes can further restrict the parents entityTypes + * restrictions by specifying a subset of the entityTypes. + * + * An empty entityTypes list when there are no parent restrictions means there are no + * restrictions. + * + * An empty entityTypes list when there are parent + * restrictions means that the subtype picks up the parents + * restrictions. + * + * If a list of entityTypes are supplied, where one inherits + * from another, this will be rejected. This should encourage cleaner + * classificationsDefs. + * + */ + entityTypes?: string[]; + /** An array of sub types. */ + subTypes?: string[]; + /** An array of super types. */ + superTypes?: string[]; +} + +/** class that captures details of a entity-type. */ +export interface AtlasEntityDefOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormatOutput; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; + /** An array of sub types. */ + subTypes?: string[]; + /** An array of super types. */ + superTypes?: string[]; + /** An array of relationship attributes. */ + relationshipAttributeDefs?: Array; +} + +/** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ +export interface AtlasRelationshipAttributeDefOutput { + /** + * single-valued attribute or multi-valued attribute. + * + * Possible values: SINGLE, LIST, SET + */ + cardinality?: string; + /** An array of constraints. */ + constraints?: Array; + /** The default value of the attribute. */ + defaultValue?: string; + /** The description of the attribute. */ + description?: string; + /** Determines if it is included in notification. */ + includeInNotification?: boolean; + /** Determines if it is indexable. */ + isIndexable?: boolean; + /** Determines if it is optional. */ + isOptional?: boolean; + /** Determines if it unique. */ + isUnique?: boolean; + /** The name of the attribute. */ + name?: string; + /** The options for the attribute. */ + options?: Record; + /** The name of the type. */ + typeName?: string; + /** The maximum count of the values. */ + valuesMaxCount?: number; + /** The minimum count of the values. */ + valuesMinCount?: number; + /** Determines if it is a legacy attribute. */ + isLegacyAttribute?: boolean; + /** The name of the relationship type. */ + relationshipTypeName?: string; +} + +/** class that captures details of an enum-type. */ +export interface AtlasEnumDefOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormatOutput; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** The default value. */ + defaultValue?: string; + /** An array of enum element definitions. */ + elementDefs?: Array; +} + +/** class that captures details of an enum-element. */ +export interface AtlasEnumElementDefOutput { + /** The description of the enum element definition. */ + description?: string; + /** The ordinal of the enum element definition. */ + ordinal?: number; + /** The value of the enum element definition. */ + value?: string; +} + +/** + * AtlasRelationshipDef is a TypeDef that defines a relationship. + * As with other typeDefs the AtlasRelationshipDef has a name. Once created the + * RelationshipDef has a guid. + * The name and the guid are the 2 ways that the + * RelationshipDef is identified. + * RelationshipDefs have 2 ends, each of which + * specify cardinality, an EntityDef type name and name and optionally + * whether the + * end is a container. + * RelationshipDefs can have AttributeDefs - though only + * primitive types are allowed. + * RelationshipDefs have a relationshipCategory + * specifying the UML type of relationship required + * The way EntityDefs and + * RelationshipDefs are intended to be used is that EntityDefs will define + * AttributeDefs these AttributeDefs + * will not specify an EntityDef type name as + * their types. + * RelationshipDefs introduce new attributes to the entity + * instances. For example + * EntityDef A might have attributes attr1,attr2,attr3 + * + * EntityDef B might have attributes attr4,attr5,attr6 + * RelationshipDef + * AtoB might define 2 ends + * + * end1: type A, name attr7 + * end2: type B, name attr8 + * + * When an instance of EntityDef A is created, it + * will have attributes attr1,attr2,attr3,attr7 + * When an instance of EntityDef + * B is created, it will have attributes attr4,attr5,attr6,attr8 + * + * In this way + * relationshipDefs can be authored separately from entityDefs and can inject + * relationship attributes into + * the entity instances + */ +export interface AtlasRelationshipDefOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormatOutput; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; + /** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ + endDef1?: AtlasRelationshipEndDefOutput; + /** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ + endDef2?: AtlasRelationshipEndDefOutput; + /** + * The Relationship category determines the style of relationship around + * containment and lifecycle. + * UML terminology is used for the values. + * ASSOCIATION is a relationship with no containment. + * COMPOSITION and AGGREGATION are containment relationships. + * The difference being in the lifecycles of the container and its children. + * In the COMPOSITION case, the children cannot exist without the container. + * For AGGREGATION, the life cycles of the container and children are totally independent. + * + * Possible values: ASSOCIATION, AGGREGATION, COMPOSITION + */ + relationshipCategory?: string; + /** The label of the relationship. */ + relationshipLabel?: string; +} + +/** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ +export interface AtlasRelationshipEndDefOutput { + /** + * single-valued attribute or multi-valued attribute. + * + * Possible values: SINGLE, LIST, SET + */ + cardinality?: string; + /** The description of the relationship end definition. */ + description?: string; + /** Determines if it is container. */ + isContainer?: boolean; + /** Determines if it is a legacy attribute. */ + isLegacyAttribute?: boolean; + /** The name of the relationship end definition. */ + name?: string; + /** The type of the relationship end. */ + type?: string; +} + +/** class that captures details of a struct-type. */ +export interface AtlasStructDefOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormatOutput; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; +} + +/** The definitions of type. */ +export interface AtlasTypeDefOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormatOutput; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** + * Specifying a list of entityType names in the classificationDef, ensures that + * classifications can + * only be applied to those entityTypes. + * + * Any subtypes of the entity types inherit the restriction. + * + * Any classificationDef subtypes inherit the parents entityTypes restrictions. + * + * Any classificationDef subtypes can further restrict the parents entityTypes + * restrictions by specifying a subset of the entityTypes. + * + * An empty entityTypes list when there are no parent restrictions means there are no + * restrictions. + * + * An empty entityTypes list when there are parent + * restrictions means that the subtype picks up the parents + * restrictions. + * + * If a list of entityTypes are supplied, where one inherits + * from another, this will be rejected. This should encourage cleaner + * classificationsDefs. + * + */ + entityTypes?: string[]; + /** An array of sub types. */ + subTypes?: string[]; + /** An array of super types. */ + superTypes?: string[]; + /** An array of relationship attributes. */ + relationshipAttributeDefs?: Array; + /** The default value. */ + defaultValue?: string; + /** An array of enum element definitions. */ + elementDefs?: Array; + /** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ + endDef1?: AtlasRelationshipEndDefOutput; + /** + * The relationshipEndDef represents an end of the relationship. The end of the + * relationship is defined by a type, an + * attribute name, cardinality and whether + * it is the container end of the relationship. + */ + endDef2?: AtlasRelationshipEndDefOutput; + /** + * The Relationship category determines the style of relationship around + * containment and lifecycle. + * UML terminology is used for the values. + * + * ASSOCIATION is a relationship with no containment. + * COMPOSITION and AGGREGATION are containment relationships. + * + * The difference being in the lifecycles of the container and its children. + * In the COMPOSITION case, the children cannot exist without the container. + * For AGGREGATION, the life cycles of the container and children are totally independent. + * + * Possible values: ASSOCIATION, AGGREGATION, COMPOSITION + */ + relationshipCategory?: string; + /** The label of the relationship. */ + relationshipLabel?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; +} + +/** The definitions of types. */ +export interface AtlasTypesDefOutput { + /** businessMetadataDefs */ + businessMetadataDefs?: Array; + /** An array of classification definitions. */ + classificationDefs?: Array; + /** An array of entity definitions. */ + entityDefs?: Array; + /** An array of enum definitions. */ + enumDefs?: Array; + /** An array of relationship definitions. */ + relationshipDefs?: Array; + /** An array of struct definitions. */ + structDefs?: Array; + /** An array of term template definitions. */ + termTemplateDefs?: Array; +} + +/** Term template definition for glossary term. */ +export interface TermTemplateDefOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The created time of the record. */ + createTime?: number; + /** The user who created the record. */ + createdBy?: string; + /** The date format. */ + dateFormatter?: DateFormatOutput; + /** The description of the type definition. */ + description?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; + /** The options for the type definition. */ + options?: Record; + /** The service type. */ + serviceType?: string; + /** The version of the type. */ + typeVersion?: string; + /** The update time of the record. */ + updateTime?: number; + /** The user who updated the record. */ + updatedBy?: string; + /** The version of the record. */ + version?: number; + /** ETag for concurrency control. */ + lastModifiedTS?: string; + /** An array of attribute definitions. */ + attributeDefs?: Array; +} + +/** The basic information of the type definition. */ +export interface AtlasTypeDefHeaderOutput { + /** + * The enum of type category. + * + * Possible values: PRIMITIVE, OBJECT_ID_TYPE, ENUM, STRUCT, CLASSIFICATION, ENTITY, ARRAY, MAP, RELATIONSHIP, TERM_TEMPLATE + */ + category?: string; + /** The GUID of the type definition. */ + guid?: string; + /** The name of the type definition. */ + name?: string; +} diff --git a/sdk/purview/purview-datamap-rest/src/parameters.ts b/sdk/purview/purview-datamap-rest/src/parameters.ts new file mode 100644 index 000000000000..fd175e6c7da7 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/parameters.ts @@ -0,0 +1,1023 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import { RequestParameters } from "@azure-rest/core-client"; +import { + AtlasEntityWithExtInfo, + AtlasEntitiesWithExtInfo, + ClassificationAssociateContent, + AtlasClassification, + AtlasEntityHeaders, + MoveEntitiesContent, + AtlasGlossary, + AtlasGlossaryCategory, + AtlasGlossaryTerm, + AtlasRelatedObjectId, + SearchContent, + SuggestContent, + AutoCompleteContent, + AtlasRelationship, + AtlasTypesDef, +} from "./models"; + +export interface EntityCreateOrUpdateBodyParam { + /** Atlas entity with extended information. */ + body: AtlasEntityWithExtInfo; +} + +export interface EntityCreateOrUpdateQueryParamProperties { + /** + * Used to define the update behavior for business attributes when updating + * entities. + * + * Possible values: ignore, replace, merge + */ + businessAttributeUpdateBehavior?: string; + /** + * The collection where entities will be moved to. Only specify a value if you + * need to move an entity to another collection. + */ + collectionId?: string; +} + +export interface EntityCreateOrUpdateQueryParam { + queryParameters?: EntityCreateOrUpdateQueryParamProperties; +} + +export type EntityCreateOrUpdateParameters = EntityCreateOrUpdateQueryParam & + EntityCreateOrUpdateBodyParam & + RequestParameters; + +export interface EntityListByGuidsQueryParamProperties { + /** An array of GUIDs of entities to list. This parameter needs to be formatted as multi collection, we provide buildMultiCollection from serializeHelper.ts to help, you will probably need to set skipUrlEncoding as true when sending the request */ + guid: string; + /** Whether to return minimal information for referred entities. */ + minExtInfo?: boolean; + /** Whether to ignore relationship attributes. */ + ignoreRelationships?: boolean; +} + +export interface EntityListByGuidsQueryParam { + queryParameters: EntityListByGuidsQueryParamProperties; +} + +export type EntityListByGuidsParameters = EntityListByGuidsQueryParam & + RequestParameters; + +export interface EntityBulkCreateOrUpdateBodyParam { + /** An array of entities to create or update. */ + body: AtlasEntitiesWithExtInfo; +} + +export interface EntityBulkCreateOrUpdateQueryParamProperties { + /** + * The collection where entities will be moved to. Only specify a value if you + * need to move an entity to another collection. + */ + collectionId?: string; + /** + * Used to define the update behavior for business attributes when updating + * entities. + * + * Possible values: ignore, replace, merge + */ + businessAttributeUpdateBehavior?: string; +} + +export interface EntityBulkCreateOrUpdateQueryParam { + queryParameters?: EntityBulkCreateOrUpdateQueryParamProperties; +} + +export type EntityBulkCreateOrUpdateParameters = + EntityBulkCreateOrUpdateQueryParam & + EntityBulkCreateOrUpdateBodyParam & + RequestParameters; + +export interface EntityBulkDeleteQueryParamProperties { + /** An array of GUIDs of entities to delete. This parameter needs to be formatted as multi collection, we provide buildMultiCollection from serializeHelper.ts to help, you will probably need to set skipUrlEncoding as true when sending the request */ + guid: string; +} + +export interface EntityBulkDeleteQueryParam { + queryParameters: EntityBulkDeleteQueryParamProperties; +} + +export type EntityBulkDeleteParameters = EntityBulkDeleteQueryParam & + RequestParameters; + +export interface EntityAddClassificationBodyParam { + /** The request to associate a classification to multiple entities. */ + body: ClassificationAssociateContent; +} + +export type EntityAddClassificationParameters = + EntityAddClassificationBodyParam & RequestParameters; + +export interface EntityGetQueryParamProperties { + /** Whether to return minimal information for referred entities. */ + minExtInfo?: boolean; + /** Whether to ignore relationship attributes. */ + ignoreRelationships?: boolean; +} + +export interface EntityGetQueryParam { + queryParameters?: EntityGetQueryParamProperties; +} + +export type EntityGetParameters = EntityGetQueryParam & RequestParameters; + +export interface EntityPartialUpdateAttributeByGuidBodyParam { + /** The value of the attribute. */ + body: unknown; +} + +export interface EntityPartialUpdateAttributeByGuidQueryParamProperties { + /** The name of the attribute. */ + name: string; +} + +export interface EntityPartialUpdateAttributeByGuidQueryParam { + queryParameters: EntityPartialUpdateAttributeByGuidQueryParamProperties; +} + +export type EntityPartialUpdateAttributeByGuidParameters = + EntityPartialUpdateAttributeByGuidQueryParam & + EntityPartialUpdateAttributeByGuidBodyParam & + RequestParameters; +export type EntityDeleteParameters = RequestParameters; +export type EntityGetClassificationParameters = RequestParameters; +export type EntityRemoveClassificationParameters = RequestParameters; +export type EntityGetClassificationsParameters = RequestParameters; + +export interface EntityAddClassificationsBodyParam { + /** An array of classifications to be added. */ + body: Array; +} + +export type EntityAddClassificationsParameters = + EntityAddClassificationsBodyParam & RequestParameters; + +export interface EntityUpdateClassificationsBodyParam { + /** An array of classifications to be updated. */ + body: Array; +} + +export type EntityUpdateClassificationsParameters = + EntityUpdateClassificationsBodyParam & RequestParameters; + +export interface EntityGetByUniqueAttributesQueryParamProperties { + /** Whether to return minimal information for referred entities. */ + minExtInfo?: boolean; + /** Whether to ignore relationship attributes. */ + ignoreRelationships?: boolean; + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntityGetByUniqueAttributesQueryParam { + queryParameters?: EntityGetByUniqueAttributesQueryParamProperties; +} + +export type EntityGetByUniqueAttributesParameters = + EntityGetByUniqueAttributesQueryParam & RequestParameters; + +export interface EntityPartialUpdateByUniqueAttributesBodyParam { + /** Atlas entity with extended information. */ + body: AtlasEntityWithExtInfo; +} + +export interface EntityPartialUpdateByUniqueAttributesQueryParamProperties { + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntityPartialUpdateByUniqueAttributesQueryParam { + queryParameters?: EntityPartialUpdateByUniqueAttributesQueryParamProperties; +} + +export type EntityPartialUpdateByUniqueAttributesParameters = + EntityPartialUpdateByUniqueAttributesQueryParam & + EntityPartialUpdateByUniqueAttributesBodyParam & + RequestParameters; + +export interface EntityDeleteByUniqueAttributeQueryParamProperties { + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntityDeleteByUniqueAttributeQueryParam { + queryParameters?: EntityDeleteByUniqueAttributeQueryParamProperties; +} + +export type EntityDeleteByUniqueAttributeParameters = + EntityDeleteByUniqueAttributeQueryParam & RequestParameters; + +export interface EntityRemoveClassificationByUniqueAttributeQueryParamProperties { + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntityRemoveClassificationByUniqueAttributeQueryParam { + queryParameters?: EntityRemoveClassificationByUniqueAttributeQueryParamProperties; +} + +export type EntityRemoveClassificationByUniqueAttributeParameters = + EntityRemoveClassificationByUniqueAttributeQueryParam & RequestParameters; + +export interface EntityAddClassificationsByUniqueAttributeBodyParam { + /** An array of classification to be added. */ + body: Array; +} + +export interface EntityAddClassificationsByUniqueAttributeQueryParamProperties { + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntityAddClassificationsByUniqueAttributeQueryParam { + queryParameters?: EntityAddClassificationsByUniqueAttributeQueryParamProperties; +} + +export type EntityAddClassificationsByUniqueAttributeParameters = + EntityAddClassificationsByUniqueAttributeQueryParam & + EntityAddClassificationsByUniqueAttributeBodyParam & + RequestParameters; + +export interface EntityUpdateClassificationsByUniqueAttributeBodyParam { + /** An array of classification to be updated. */ + body: Array; +} + +export interface EntityUpdateClassificationsByUniqueAttributeQueryParamProperties { + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntityUpdateClassificationsByUniqueAttributeQueryParam { + queryParameters?: EntityUpdateClassificationsByUniqueAttributeQueryParamProperties; +} + +export type EntityUpdateClassificationsByUniqueAttributeParameters = + EntityUpdateClassificationsByUniqueAttributeQueryParam & + EntityUpdateClassificationsByUniqueAttributeBodyParam & + RequestParameters; + +export interface EntityBulkSetClassificationsBodyParam { + /** Atlas entity headers. */ + body: AtlasEntityHeaders; +} + +export type EntityBulkSetClassificationsParameters = + EntityBulkSetClassificationsBodyParam & RequestParameters; + +export interface EntityListByUniqueAttributesQueryParamProperties { + /** Whether to return minimal information for referred entities. */ + minExtInfo?: boolean; + /** Whether to ignore relationship attributes. */ + ignoreRelationships?: boolean; + /** + * Qualified name of an entity. E.g. to find 2 entities you can set + * attrs_1:qualifiedName=db1@cl1&attrs_2:qualifiedName=db2@cl1. (This is only an + * example. qualifiedName can be changed to other unique attributes) + */ + "attr_N:qualifiedName"?: string; +} + +export interface EntityListByUniqueAttributesQueryParam { + queryParameters?: EntityListByUniqueAttributesQueryParamProperties; +} + +export type EntityListByUniqueAttributesParameters = + EntityListByUniqueAttributesQueryParam & RequestParameters; +export type EntityGetHeaderParameters = RequestParameters; + +export interface EntityRemoveBusinessMetadataBodyParam { + /** Business metadata payload */ + body: Record>; +} + +export type EntityRemoveBusinessMetadataParameters = + EntityRemoveBusinessMetadataBodyParam & RequestParameters; + +export interface EntityAddOrUpdateBusinessMetadataBodyParam { + /** BusinessMetadata payload */ + body: Record>; +} + +export interface EntityAddOrUpdateBusinessMetadataQueryParamProperties { + /** + * Whether to overwrite the existing business metadata on the entity or not, + * default is false. + */ + isOverwrite?: boolean; +} + +export interface EntityAddOrUpdateBusinessMetadataQueryParam { + queryParameters?: EntityAddOrUpdateBusinessMetadataQueryParamProperties; +} + +export type EntityAddOrUpdateBusinessMetadataParameters = + EntityAddOrUpdateBusinessMetadataQueryParam & + EntityAddOrUpdateBusinessMetadataBodyParam & + RequestParameters; + +export interface EntityRemoveBusinessMetadataAttributesBodyParam { + /** Business metadata attribute payload */ + body: Record; +} + +export type EntityRemoveBusinessMetadataAttributesParameters = + EntityRemoveBusinessMetadataAttributesBodyParam & RequestParameters; + +export interface EntityAddOrUpdateBusinessMetadataAttributesBodyParam { + /** Business metadata attribute payload */ + body: Record; +} + +export type EntityAddOrUpdateBusinessMetadataAttributesParameters = + EntityAddOrUpdateBusinessMetadataAttributesBodyParam & RequestParameters; +export type EntityGetSampleBusinessMetadataTemplateParameters = + RequestParameters; + +export interface EntityImportBusinessMetadataBodyParam { + body?: { uploadedInputStream: string }; +} + +export interface EntityImportBusinessMetadataMediaTypesParam { + /** The content type for the operation. Always multipart/form-data for this operation. */ + contentType: "multipart/form-data"; +} + +export type EntityImportBusinessMetadataParameters = + EntityImportBusinessMetadataMediaTypesParam & + EntityImportBusinessMetadataBodyParam & + RequestParameters; + +export interface EntityRemoveLabelsBodyParam { + /** set of labels to be deleted */ + body: string[]; +} + +export type EntityRemoveLabelsParameters = EntityRemoveLabelsBodyParam & + RequestParameters; + +export interface EntitySetLabelsBodyParam { + /** set of labels to be set to the entity */ + body: string[]; +} + +export type EntitySetLabelsParameters = EntitySetLabelsBodyParam & + RequestParameters; + +export interface EntityAddLabelBodyParam { + /** set of labels to be added */ + body: string[]; +} + +export type EntityAddLabelParameters = EntityAddLabelBodyParam & + RequestParameters; + +export interface EntityRemoveLabelsByUniqueAttributeBodyParam { + /** set of labels to be deleted */ + body: string[]; +} + +export interface EntityRemoveLabelsByUniqueAttributeQueryParamProperties { + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntityRemoveLabelsByUniqueAttributeQueryParam { + queryParameters?: EntityRemoveLabelsByUniqueAttributeQueryParamProperties; +} + +export type EntityRemoveLabelsByUniqueAttributeParameters = + EntityRemoveLabelsByUniqueAttributeQueryParam & + EntityRemoveLabelsByUniqueAttributeBodyParam & + RequestParameters; + +export interface EntitySetLabelsByUniqueAttributeBodyParam { + /** set of labels to be set */ + body: string[]; +} + +export interface EntitySetLabelsByUniqueAttributeQueryParamProperties { + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntitySetLabelsByUniqueAttributeQueryParam { + queryParameters?: EntitySetLabelsByUniqueAttributeQueryParamProperties; +} + +export type EntitySetLabelsByUniqueAttributeParameters = + EntitySetLabelsByUniqueAttributeQueryParam & + EntitySetLabelsByUniqueAttributeBodyParam & + RequestParameters; + +export interface EntityAddLabelsByUniqueAttributeBodyParam { + /** set of labels to be added */ + body: string[]; +} + +export interface EntityAddLabelsByUniqueAttributeQueryParamProperties { + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface EntityAddLabelsByUniqueAttributeQueryParam { + queryParameters?: EntityAddLabelsByUniqueAttributeQueryParamProperties; +} + +export type EntityAddLabelsByUniqueAttributeParameters = + EntityAddLabelsByUniqueAttributeQueryParam & + EntityAddLabelsByUniqueAttributeBodyParam & + RequestParameters; + +export interface EntityMoveEntitiesToCollectionBodyParam { + /** Entity guids to be moved to target collection. */ + body: MoveEntitiesContent; +} + +export interface EntityMoveEntitiesToCollectionQueryParamProperties { + /** The collection where entities will be moved to. */ + collectionId: string; +} + +export interface EntityMoveEntitiesToCollectionQueryParam { + queryParameters: EntityMoveEntitiesToCollectionQueryParamProperties; +} + +export type EntityMoveEntitiesToCollectionParameters = + EntityMoveEntitiesToCollectionQueryParam & + EntityMoveEntitiesToCollectionBodyParam & + RequestParameters; + +export interface GlossaryListQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; + /** Whether ignore terms and categories */ + ignoreTermsAndCategories?: boolean; +} + +export interface GlossaryListQueryParam { + queryParameters?: GlossaryListQueryParamProperties; +} + +export type GlossaryListParameters = GlossaryListQueryParam & RequestParameters; + +export interface GlossaryCreateBodyParam { + /** + * Glossary definition, terms & categories can be anchored to a glossary. + * Using + * the anchor attribute when creating the Term/Category. + */ + body: AtlasGlossary; +} + +export type GlossaryCreateParameters = GlossaryCreateBodyParam & + RequestParameters; + +export interface GlossaryCreateCategoriesBodyParam { + /** An array of glossary category definitions to be created. */ + body: Array; +} + +export type GlossaryCreateCategoriesParameters = + GlossaryCreateCategoriesBodyParam & RequestParameters; + +export interface GlossaryCreateCategoryBodyParam { + /** + * The glossary category definition. A category must be anchored to a Glossary + * when creating. + * Optionally, terms belonging to the category and the hierarchy + * can also be defined during creation. + */ + body: AtlasGlossaryCategory; +} + +export type GlossaryCreateCategoryParameters = GlossaryCreateCategoryBodyParam & + RequestParameters; +export type GlossaryGetCategoryParameters = RequestParameters; + +export interface GlossaryUpdateCategoryBodyParam { + /** The glossary category to be updated. */ + body: AtlasGlossaryCategory; +} + +export type GlossaryUpdateCategoryParameters = GlossaryUpdateCategoryBodyParam & + RequestParameters; +export type GlossaryDeleteCategoryParameters = RequestParameters; + +export interface GlossaryPartialUpdateCategoryBodyParam { + /** + * A map containing keys as attribute names and values as corresponding attribute + * values for partial update. + */ + body: unknown; +} + +export type GlossaryPartialUpdateCategoryParameters = + GlossaryPartialUpdateCategoryBodyParam & RequestParameters; + +export interface GlossaryListRelatedCategoriesQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; +} + +export interface GlossaryListRelatedCategoriesQueryParam { + queryParameters?: GlossaryListRelatedCategoriesQueryParamProperties; +} + +export type GlossaryListRelatedCategoriesParameters = + GlossaryListRelatedCategoriesQueryParam & RequestParameters; + +export interface GlossaryListCategoryTermsQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; +} + +export interface GlossaryListCategoryTermsQueryParam { + queryParameters?: GlossaryListCategoryTermsQueryParamProperties; +} + +export type GlossaryListCategoryTermsParameters = + GlossaryListCategoryTermsQueryParam & RequestParameters; + +export interface GlossaryCreateTermBodyParam { + /** + * The glossary term definition. A term must be anchored to a Glossary at the time + * of creation. + * Optionally it can be categorized as well. + */ + body: AtlasGlossaryTerm; +} + +export interface GlossaryCreateTermQueryParamProperties { + /** Whether include term hierarchy */ + includeTermHierarchy?: boolean; +} + +export interface GlossaryCreateTermQueryParam { + queryParameters?: GlossaryCreateTermQueryParamProperties; +} + +export type GlossaryCreateTermParameters = GlossaryCreateTermQueryParam & + GlossaryCreateTermBodyParam & + RequestParameters; +export type GlossaryGetTermParameters = RequestParameters; + +export interface GlossaryUpdateTermBodyParam { + /** The glossary term to be updated. */ + body: AtlasGlossaryTerm; +} + +export interface GlossaryUpdateTermQueryParamProperties { + /** Whether include term hierarchy */ + includeTermHierarchy?: boolean; +} + +export interface GlossaryUpdateTermQueryParam { + queryParameters?: GlossaryUpdateTermQueryParamProperties; +} + +export type GlossaryUpdateTermParameters = GlossaryUpdateTermQueryParam & + GlossaryUpdateTermBodyParam & + RequestParameters; +export type GlossaryDeleteTermParameters = RequestParameters; + +export interface GlossaryPartialUpdateTermBodyParam { + /** + * A map containing keys as attribute names and values as corresponding attribute + * values to be updated. + */ + body: unknown; +} + +export interface GlossaryPartialUpdateTermQueryParamProperties { + /** Whether include term hierarchy */ + includeTermHierarchy?: boolean; +} + +export interface GlossaryPartialUpdateTermQueryParam { + queryParameters?: GlossaryPartialUpdateTermQueryParamProperties; +} + +export type GlossaryPartialUpdateTermParameters = + GlossaryPartialUpdateTermQueryParam & + GlossaryPartialUpdateTermBodyParam & + RequestParameters; + +export interface GlossaryCreateTermsBodyParam { + /** An array of glossary term definitions to be created in bulk. */ + body: Array; +} + +export interface GlossaryCreateTermsQueryParamProperties { + /** Whether include term hierarchy */ + includeTermHierarchy?: boolean; +} + +export interface GlossaryCreateTermsQueryParam { + queryParameters?: GlossaryCreateTermsQueryParamProperties; +} + +export type GlossaryCreateTermsParameters = GlossaryCreateTermsQueryParam & + GlossaryCreateTermsBodyParam & + RequestParameters; + +export interface GlossaryListEntitiesAssignedWithTermQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; +} + +export interface GlossaryListEntitiesAssignedWithTermQueryParam { + queryParameters?: GlossaryListEntitiesAssignedWithTermQueryParamProperties; +} + +export type GlossaryListEntitiesAssignedWithTermParameters = + GlossaryListEntitiesAssignedWithTermQueryParam & RequestParameters; + +export interface GlossaryAssignTermToEntitiesBodyParam { + /** An array of related object IDs to which the term has to be associated. */ + body: Array; +} + +export type GlossaryAssignTermToEntitiesParameters = + GlossaryAssignTermToEntitiesBodyParam & RequestParameters; + +export interface GlossaryDeleteTermAssignmentFromEntitiesBodyParam { + /** An array of related object IDs from which the term has to be dissociated. */ + body: Array; +} + +export type GlossaryDeleteTermAssignmentFromEntitiesParameters = + GlossaryDeleteTermAssignmentFromEntitiesBodyParam & RequestParameters; + +export interface GlossaryListRelatedTermsQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; +} + +export interface GlossaryListRelatedTermsQueryParam { + queryParameters?: GlossaryListRelatedTermsQueryParamProperties; +} + +export type GlossaryListRelatedTermsParameters = + GlossaryListRelatedTermsQueryParam & RequestParameters; +export type GlossaryGetParameters = RequestParameters; + +export interface GlossaryUpdateBodyParam { + /** The glossary definition to be updated. */ + body: AtlasGlossary; +} + +export interface GlossaryUpdateQueryParamProperties { + /** Whether ignore terms and categories */ + ignoreTermsAndCategories?: boolean; +} + +export interface GlossaryUpdateQueryParam { + queryParameters?: GlossaryUpdateQueryParamProperties; +} + +export type GlossaryUpdateParameters = GlossaryUpdateQueryParam & + GlossaryUpdateBodyParam & + RequestParameters; +export type GlossaryDeleteParameters = RequestParameters; + +export interface GlossaryListCategoriesQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; +} + +export interface GlossaryListCategoriesQueryParam { + queryParameters?: GlossaryListCategoriesQueryParamProperties; +} + +export type GlossaryListCategoriesParameters = + GlossaryListCategoriesQueryParam & RequestParameters; + +export interface GlossaryListCategoriesHeadersQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; +} + +export interface GlossaryListCategoriesHeadersQueryParam { + queryParameters?: GlossaryListCategoriesHeadersQueryParamProperties; +} + +export type GlossaryListCategoriesHeadersParameters = + GlossaryListCategoriesHeadersQueryParam & RequestParameters; +export type GlossaryGetDetailedParameters = RequestParameters; + +export interface GlossaryPartialUpdateBodyParam { + /** + * A map containing keys as attribute names and values as corresponding attribute + * values. + */ + body: unknown; +} + +export interface GlossaryPartialUpdateQueryParamProperties { + /** Whether ignore terms and categories */ + ignoreTermsAndCategories?: boolean; +} + +export interface GlossaryPartialUpdateQueryParam { + queryParameters?: GlossaryPartialUpdateQueryParamProperties; +} + +export type GlossaryPartialUpdateParameters = GlossaryPartialUpdateQueryParam & + GlossaryPartialUpdateBodyParam & + RequestParameters; + +export interface GlossaryListTermsQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; +} + +export interface GlossaryListTermsQueryParam { + queryParameters?: GlossaryListTermsQueryParamProperties; +} + +export type GlossaryListTermsParameters = GlossaryListTermsQueryParam & + RequestParameters; + +export interface GlossaryListTermHeadersQueryParamProperties { + /** The page size - by default there is no paging. */ + limit?: number; + /** The offset for pagination purpose. */ + offset?: number; + /** The sort order, ASC (default) or DESC. */ + sort?: string; +} + +export interface GlossaryListTermHeadersQueryParam { + queryParameters?: GlossaryListTermHeadersQueryParamProperties; +} + +export type GlossaryListTermHeadersParameters = + GlossaryListTermHeadersQueryParam & RequestParameters; + +export interface DiscoveryQueryBodyParam { + /** An object specifying the search criteria. */ + body: SearchContent; +} + +export type DiscoveryQueryParameters = DiscoveryQueryBodyParam & + RequestParameters; + +export interface DiscoverySuggestBodyParam { + /** An object specifying the suggest criteria. */ + body: SuggestContent; +} + +export type DiscoverySuggestParameters = DiscoverySuggestBodyParam & + RequestParameters; + +export interface DiscoveryAutoCompleteBodyParam { + /** An object specifying the autocomplete criteria. */ + body: AutoCompleteContent; +} + +export type DiscoveryAutoCompleteParameters = DiscoveryAutoCompleteBodyParam & + RequestParameters; + +export interface LineageGetQueryParamProperties { + /** The number of hops for lineage. */ + depth?: number; + /** + * The direction of the lineage, which could be INPUT, OUTPUT or BOTH. + * + * Possible values: INPUT, OUTPUT, BOTH + */ + direction: string; +} + +export interface LineageGetQueryParam { + queryParameters: LineageGetQueryParamProperties; +} + +export type LineageGetParameters = LineageGetQueryParam & RequestParameters; + +export interface LineageGetNextPageQueryParamProperties { + /** + * The direction of the lineage, which could be INPUT, OUTPUT or BOTH. + * + * Possible values: INPUT, OUTPUT, BOTH + */ + direction: string; + /** The offset for pagination purpose. */ + offset?: number; + /** The page size - by default there is no paging. */ + limit?: number; +} + +export interface LineageGetNextPageQueryParam { + queryParameters: LineageGetNextPageQueryParamProperties; +} + +export type LineageGetNextPageParameters = LineageGetNextPageQueryParam & + RequestParameters; + +export interface LineageGetByUniqueAttributeQueryParamProperties { + /** The number of hops for lineage. */ + depth?: number; + /** + * The direction of the lineage, which could be INPUT, OUTPUT or BOTH. + * + * Possible values: INPUT, OUTPUT, BOTH + */ + direction: string; + /** + * The qualified name of the entity. (This is only an example. qualifiedName can + * be changed to other unique attributes) + */ + "attr:qualifiedName"?: string; +} + +export interface LineageGetByUniqueAttributeQueryParam { + queryParameters: LineageGetByUniqueAttributeQueryParamProperties; +} + +export type LineageGetByUniqueAttributeParameters = + LineageGetByUniqueAttributeQueryParam & RequestParameters; + +export interface RelationshipCreateBodyParam { + /** + * The AtlasRelationship object containing the information for the relationship to + * be created. + */ + body: AtlasRelationship; +} + +export type RelationshipCreateParameters = RelationshipCreateBodyParam & + RequestParameters; + +export interface RelationshipUpdateBodyParam { + /** + * The AtlasRelationship object containing the information for the relationship to + * be created. + */ + body: AtlasRelationship; +} + +export type RelationshipUpdateParameters = RelationshipUpdateBodyParam & + RequestParameters; + +export interface RelationshipGetQueryParamProperties { + /** Limits whether includes extended information. */ + extendedInfo?: boolean; +} + +export interface RelationshipGetQueryParam { + queryParameters?: RelationshipGetQueryParamProperties; +} + +export type RelationshipGetParameters = RelationshipGetQueryParam & + RequestParameters; +export type RelationshipDeleteParameters = RequestParameters; +export type TypeGetBusinessMetadataDefByGuidParameters = RequestParameters; +export type TypeGetBusinessMetadataDefByNameParameters = RequestParameters; +export type TypeGetClassificationDefByGuidParameters = RequestParameters; +export type TypeGetClassificationDefByNameParameters = RequestParameters; +export type TypeGetEntityDefByGuidParameters = RequestParameters; +export type TypeGetEntityDefByNameParameters = RequestParameters; +export type TypeGetEnumDefByGuidParameters = RequestParameters; +export type TypeGetEnumDefByNameParameters = RequestParameters; +export type TypeGetRelationshipDefByGuidParameters = RequestParameters; +export type TypeGetRelationshipDefByNameParameters = RequestParameters; +export type TypeGetStructDefByGuidParameters = RequestParameters; +export type TypeGetStructDefByNameParameters = RequestParameters; +export type TypeGetByGuidParameters = RequestParameters; +export type TypeGetByNameParameters = RequestParameters; +export type TypeDeleteParameters = RequestParameters; + +export interface TypeListQueryParamProperties { + /** + * Whether include termtemplatedef when return all typedefs. + * This is always true + * when search filter type=term_template + */ + includeTermTemplate?: boolean; + /** + * Typedef name as search filter when get typedefs. + * + * Possible values: enum, entity, classification, relationship, struct, term_template + */ + type?: string; +} + +export interface TypeListQueryParam { + queryParameters?: TypeListQueryParamProperties; +} + +export type TypeListParameters = TypeListQueryParam & RequestParameters; + +export interface TypeBulkCreateBodyParam { + /** A composite wrapper object with corresponding lists of the type definition. */ + body: AtlasTypesDef; +} + +export type TypeBulkCreateParameters = TypeBulkCreateBodyParam & + RequestParameters; + +export interface TypeBulkUpdateBodyParam { + /** A composite object that captures all type definition changes. */ + body: AtlasTypesDef; +} + +export type TypeBulkUpdateParameters = TypeBulkUpdateBodyParam & + RequestParameters; + +export interface TypeBulkDeleteBodyParam { + /** A composite object that captures all types to be deleted */ + body: AtlasTypesDef; +} + +export type TypeBulkDeleteParameters = TypeBulkDeleteBodyParam & + RequestParameters; + +export interface TypeListHeadersQueryParamProperties { + /** + * Whether include termtemplatedef when return all typedefs. + * This is always true + * when search filter type=term_template + */ + includeTermTemplate?: boolean; + /** + * Typedef name as search filter when get typedefs. + * + * Possible values: enum, entity, classification, relationship, struct, term_template + */ + type?: string; +} + +export interface TypeListHeadersQueryParam { + queryParameters?: TypeListHeadersQueryParamProperties; +} + +export type TypeListHeadersParameters = TypeListHeadersQueryParam & + RequestParameters; +export type TypeGetTermTemplateDefByGuidParameters = RequestParameters; +export type TypeGetTermTemplateDefByNameParameters = RequestParameters; diff --git a/sdk/purview/purview-datamap-rest/src/purviewDataMapClient.ts b/sdk/purview/purview-datamap-rest/src/purviewDataMapClient.ts new file mode 100644 index 000000000000..59c45727b138 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/purviewDataMapClient.ts @@ -0,0 +1,49 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import { getClient, ClientOptions } from "@azure-rest/core-client"; +import { logger } from "./logger"; +import { TokenCredential } from "@azure/core-auth"; +import { PurviewDataMapClient } from "./clientDefinitions"; + +/** + * Initialize a new instance of `PurviewDataMapClient` + * @param endpoint - A sequence of textual characters. + * @param credentials - uniquely identify client credential + * @param options - the parameter for all optional parameters + */ +export default function createClient( + endpoint: string, + credentials: TokenCredential, + options: ClientOptions = {} +): PurviewDataMapClient { + const baseUrl = options.baseUrl ?? `${endpoint}/datamap/api`; + options.apiVersion = options.apiVersion ?? "2023-09-01"; + const userAgentInfo = `azsdk-js-purview-datamap-rest/1.0.0-beta.1`; + const userAgentPrefix = + options.userAgentOptions && options.userAgentOptions.userAgentPrefix + ? `${options.userAgentOptions.userAgentPrefix} ${userAgentInfo}` + : `${userAgentInfo}`; + options = { + ...options, + userAgentOptions: { + userAgentPrefix, + }, + loggingOptions: { + logger: options.loggingOptions?.logger ?? logger.info, + }, + credentials: { + scopes: options.credentials?.scopes ?? [ + "https://purview.azure.net/.default", + ], + }, + }; + + const client = getClient( + baseUrl, + credentials, + options + ) as PurviewDataMapClient; + + return client; +} diff --git a/sdk/purview/purview-datamap-rest/src/responses.ts b/sdk/purview/purview-datamap-rest/src/responses.ts new file mode 100644 index 000000000000..a9dfb6653fae --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/responses.ts @@ -0,0 +1,1125 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import { HttpResponse } from "@azure-rest/core-client"; +import { + EntityMutationResultOutput, + AtlasErrorResponseOutput, + AtlasEntitiesWithExtInfoOutput, + AtlasEntityWithExtInfoOutput, + AtlasClassificationOutput, + AtlasClassificationsOutput, + AtlasEntityHeaderOutput, + BulkImportResultOutput, + AtlasGlossaryOutput, + AtlasGlossaryCategoryOutput, + AtlasRelatedTermHeaderOutput, + AtlasGlossaryTermOutput, + AtlasRelatedObjectIdOutput, + AtlasRelatedCategoryHeaderOutput, + AtlasGlossaryExtInfoOutput, + SearchResultOutput, + SuggestResultOutput, + AutoCompleteResultOutput, + AtlasLineageInfoOutput, + AtlasRelationshipOutput, + AtlasRelationshipWithExtInfoOutput, + AtlasBusinessMetadataDefOutput, + AtlasClassificationDefOutput, + AtlasEntityDefOutput, + AtlasEnumDefOutput, + AtlasRelationshipDefOutput, + AtlasStructDefOutput, + AtlasTypeDefOutput, + AtlasTypesDefOutput, + AtlasTypeDefHeaderOutput, + TermTemplateDefOutput, +} from "./outputModels"; + +/** The request has succeeded. */ +export interface EntityCreateOrUpdate200Response extends HttpResponse { + status: "200"; + body: EntityMutationResultOutput; +} + +export interface EntityCreateOrUpdateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityListByGuids200Response extends HttpResponse { + status: "200"; + body: AtlasEntitiesWithExtInfoOutput; +} + +export interface EntityListByGuidsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityBulkCreateOrUpdate200Response extends HttpResponse { + status: "200"; + body: EntityMutationResultOutput; +} + +export interface EntityBulkCreateOrUpdateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityBulkDelete200Response extends HttpResponse { + status: "200"; + body: EntityMutationResultOutput; +} + +export interface EntityBulkDeleteDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityAddClassification204Response extends HttpResponse { + status: "204"; +} + +export interface EntityAddClassificationDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityGet200Response extends HttpResponse { + status: "200"; + body: AtlasEntityWithExtInfoOutput; +} + +export interface EntityGetDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityPartialUpdateAttributeByGuid200Response + extends HttpResponse { + status: "200"; + body: EntityMutationResultOutput; +} + +export interface EntityPartialUpdateAttributeByGuidDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityDeleteOperation200Response extends HttpResponse { + status: "200"; + body: EntityMutationResultOutput; +} + +export interface EntityDeleteOperationDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityGetClassification200Response extends HttpResponse { + status: "200"; + body: AtlasClassificationOutput; +} + +export interface EntityGetClassificationDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityRemoveClassification204Response extends HttpResponse { + status: "204"; +} + +export interface EntityRemoveClassificationDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityGetClassifications200Response extends HttpResponse { + status: "200"; + body: AtlasClassificationsOutput; +} + +export interface EntityGetClassificationsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityAddClassifications204Response extends HttpResponse { + status: "204"; +} + +export interface EntityAddClassificationsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityUpdateClassifications204Response extends HttpResponse { + status: "204"; +} + +export interface EntityUpdateClassificationsDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityGetByUniqueAttributes200Response extends HttpResponse { + status: "200"; + body: AtlasEntityWithExtInfoOutput; +} + +export interface EntityGetByUniqueAttributesDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityPartialUpdateByUniqueAttributes200Response + extends HttpResponse { + status: "200"; + body: EntityMutationResultOutput; +} + +export interface EntityPartialUpdateByUniqueAttributesDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityDeleteByUniqueAttribute200Response extends HttpResponse { + status: "200"; + body: EntityMutationResultOutput; +} + +export interface EntityDeleteByUniqueAttributeDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityRemoveClassificationByUniqueAttribute204Response + extends HttpResponse { + status: "204"; +} + +export interface EntityRemoveClassificationByUniqueAttributeDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityAddClassificationsByUniqueAttribute204Response + extends HttpResponse { + status: "204"; +} + +export interface EntityAddClassificationsByUniqueAttributeDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityUpdateClassificationsByUniqueAttribute204Response + extends HttpResponse { + status: "204"; +} + +export interface EntityUpdateClassificationsByUniqueAttributeDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityBulkSetClassifications200Response extends HttpResponse { + status: "200"; + body: string[]; +} + +export interface EntityBulkSetClassificationsDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityListByUniqueAttributes200Response extends HttpResponse { + status: "200"; + body: AtlasEntitiesWithExtInfoOutput; +} + +export interface EntityListByUniqueAttributesDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityGetHeader200Response extends HttpResponse { + status: "200"; + body: AtlasEntityHeaderOutput; +} + +export interface EntityGetHeaderDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityRemoveBusinessMetadata204Response extends HttpResponse { + status: "204"; +} + +export interface EntityRemoveBusinessMetadataDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityAddOrUpdateBusinessMetadata204Response + extends HttpResponse { + status: "204"; +} + +export interface EntityAddOrUpdateBusinessMetadataDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityRemoveBusinessMetadataAttributes204Response + extends HttpResponse { + status: "204"; +} + +export interface EntityRemoveBusinessMetadataAttributesDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityAddOrUpdateBusinessMetadataAttributes204Response + extends HttpResponse { + status: "204"; +} + +export interface EntityAddOrUpdateBusinessMetadataAttributesDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityGetSampleBusinessMetadataTemplate200Response + extends HttpResponse { + status: "200"; + /** Value may contain any sequence of octets */ + body: Uint8Array; +} + +export interface EntityGetSampleBusinessMetadataTemplateDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityImportBusinessMetadata200Response extends HttpResponse { + status: "200"; + body: BulkImportResultOutput; +} + +export interface EntityImportBusinessMetadataDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityRemoveLabels204Response extends HttpResponse { + status: "204"; +} + +export interface EntityRemoveLabelsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntitySetLabels204Response extends HttpResponse { + status: "204"; +} + +export interface EntitySetLabelsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityAddLabel204Response extends HttpResponse { + status: "204"; +} + +export interface EntityAddLabelDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityRemoveLabelsByUniqueAttribute204Response + extends HttpResponse { + status: "204"; +} + +export interface EntityRemoveLabelsByUniqueAttributeDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntitySetLabelsByUniqueAttribute204Response + extends HttpResponse { + status: "204"; +} + +export interface EntitySetLabelsByUniqueAttributeDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface EntityAddLabelsByUniqueAttribute204Response + extends HttpResponse { + status: "204"; +} + +export interface EntityAddLabelsByUniqueAttributeDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface EntityMoveEntitiesToCollection200Response + extends HttpResponse { + status: "200"; + body: EntityMutationResultOutput; +} + +export interface EntityMoveEntitiesToCollectionDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryList200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryListDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryCreate200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryOutput; +} + +export interface GlossaryCreateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryCreateCategories200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryCreateCategoriesDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryCreateCategory200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryCategoryOutput; +} + +export interface GlossaryCreateCategoryDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryGetCategory200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryCategoryOutput; +} + +export interface GlossaryGetCategoryDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryUpdateCategory200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryCategoryOutput; +} + +export interface GlossaryUpdateCategoryDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface GlossaryDeleteCategory204Response extends HttpResponse { + status: "204"; +} + +export interface GlossaryDeleteCategoryDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryPartialUpdateCategory200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryCategoryOutput; +} + +export interface GlossaryPartialUpdateCategoryDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryListRelatedCategories200Response extends HttpResponse { + status: "200"; + body: Record>; +} + +export interface GlossaryListRelatedCategoriesDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryListCategoryTerms200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryListCategoryTermsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryCreateTerm200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryTermOutput; +} + +export interface GlossaryCreateTermDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryGetTerm200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryTermOutput; +} + +export interface GlossaryGetTermDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryUpdateTerm200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryTermOutput; +} + +export interface GlossaryUpdateTermDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface GlossaryDeleteTerm204Response extends HttpResponse { + status: "204"; +} + +export interface GlossaryDeleteTermDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryPartialUpdateTerm200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryTermOutput; +} + +export interface GlossaryPartialUpdateTermDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryCreateTerms200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryCreateTermsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryListEntitiesAssignedWithTerm200Response + extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryListEntitiesAssignedWithTermDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface GlossaryAssignTermToEntities204Response extends HttpResponse { + status: "204"; +} + +export interface GlossaryAssignTermToEntitiesDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface GlossaryDeleteTermAssignmentFromEntities204Response + extends HttpResponse { + status: "204"; +} + +export interface GlossaryDeleteTermAssignmentFromEntitiesDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryListRelatedTerms200Response extends HttpResponse { + status: "200"; + body: Record>; +} + +export interface GlossaryListRelatedTermsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryGet200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryOutput; +} + +export interface GlossaryGetDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryUpdate200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryOutput; +} + +export interface GlossaryUpdateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface GlossaryDeleteOperation204Response extends HttpResponse { + status: "204"; +} + +export interface GlossaryDeleteOperationDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryListCategories200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryListCategoriesDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryListCategoriesHeaders200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryListCategoriesHeadersDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryGetDetailed200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryExtInfoOutput; +} + +export interface GlossaryGetDetailedDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryPartialUpdate200Response extends HttpResponse { + status: "200"; + body: AtlasGlossaryOutput; +} + +export interface GlossaryPartialUpdateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryListTerms200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryListTermsDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface GlossaryListTermHeaders200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface GlossaryListTermHeadersDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface DiscoveryQuery200Response extends HttpResponse { + status: "200"; + body: SearchResultOutput; +} + +export interface DiscoveryQueryDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface DiscoverySuggest200Response extends HttpResponse { + status: "200"; + body: SuggestResultOutput; +} + +export interface DiscoverySuggestDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface DiscoveryAutoComplete200Response extends HttpResponse { + status: "200"; + body: AutoCompleteResultOutput; +} + +export interface DiscoveryAutoCompleteDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface LineageGet200Response extends HttpResponse { + status: "200"; + body: AtlasLineageInfoOutput; +} + +export interface LineageGetDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface LineageGetNextPage200Response extends HttpResponse { + status: "200"; + body: AtlasLineageInfoOutput; +} + +export interface LineageGetNextPageDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface LineageGetByUniqueAttribute200Response extends HttpResponse { + status: "200"; + body: AtlasLineageInfoOutput; +} + +export interface LineageGetByUniqueAttributeDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface RelationshipCreate200Response extends HttpResponse { + status: "200"; + body: AtlasRelationshipOutput; +} + +export interface RelationshipCreateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface RelationshipUpdate200Response extends HttpResponse { + status: "200"; + body: AtlasRelationshipOutput; +} + +export interface RelationshipUpdateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface RelationshipGet200Response extends HttpResponse { + status: "200"; + body: AtlasRelationshipWithExtInfoOutput; +} + +export interface RelationshipGetDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface RelationshipDeleteOperation204Response extends HttpResponse { + status: "204"; +} + +export interface RelationshipDeleteOperationDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetBusinessMetadataDefByGuid200Response + extends HttpResponse { + status: "200"; + body: AtlasBusinessMetadataDefOutput; +} + +export interface TypeGetBusinessMetadataDefByGuidDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetBusinessMetadataDefByName200Response + extends HttpResponse { + status: "200"; + body: AtlasBusinessMetadataDefOutput; +} + +export interface TypeGetBusinessMetadataDefByNameDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetClassificationDefByGuid200Response + extends HttpResponse { + status: "200"; + body: AtlasClassificationDefOutput; +} + +export interface TypeGetClassificationDefByGuidDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetClassificationDefByName200Response + extends HttpResponse { + status: "200"; + body: AtlasClassificationDefOutput; +} + +export interface TypeGetClassificationDefByNameDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetEntityDefByGuid200Response extends HttpResponse { + status: "200"; + body: AtlasEntityDefOutput; +} + +export interface TypeGetEntityDefByGuidDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetEntityDefByName200Response extends HttpResponse { + status: "200"; + body: AtlasEntityDefOutput; +} + +export interface TypeGetEntityDefByNameDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetEnumDefByGuid200Response extends HttpResponse { + status: "200"; + body: AtlasEnumDefOutput; +} + +export interface TypeGetEnumDefByGuidDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetEnumDefByName200Response extends HttpResponse { + status: "200"; + body: AtlasEnumDefOutput; +} + +export interface TypeGetEnumDefByNameDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetRelationshipDefByGuid200Response extends HttpResponse { + status: "200"; + body: AtlasRelationshipDefOutput; +} + +export interface TypeGetRelationshipDefByGuidDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetRelationshipDefByName200Response extends HttpResponse { + status: "200"; + body: AtlasRelationshipDefOutput; +} + +export interface TypeGetRelationshipDefByNameDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetStructDefByGuid200Response extends HttpResponse { + status: "200"; + body: AtlasStructDefOutput; +} + +export interface TypeGetStructDefByGuidDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetStructDefByName200Response extends HttpResponse { + status: "200"; + body: AtlasStructDefOutput; +} + +export interface TypeGetStructDefByNameDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetByGuid200Response extends HttpResponse { + status: "200"; + body: AtlasTypeDefOutput; +} + +export interface TypeGetByGuidDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetByName200Response extends HttpResponse { + status: "200"; + body: AtlasTypeDefOutput; +} + +export interface TypeGetByNameDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface TypeDeleteOperation204Response extends HttpResponse { + status: "204"; +} + +export interface TypeDeleteOperationDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeList200Response extends HttpResponse { + status: "200"; + body: AtlasTypesDefOutput; +} + +export interface TypeListDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeBulkCreate200Response extends HttpResponse { + status: "200"; + body: AtlasTypesDefOutput; +} + +export interface TypeBulkCreateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeBulkUpdate200Response extends HttpResponse { + status: "200"; + body: AtlasTypesDefOutput; +} + +export interface TypeBulkUpdateDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** There is no content to send for this request, but the headers may be useful. */ +export interface TypeBulkDelete204Response extends HttpResponse { + status: "204"; +} + +export interface TypeBulkDeleteDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeListHeaders200Response extends HttpResponse { + status: "200"; + body: Array; +} + +export interface TypeListHeadersDefaultResponse extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetTermTemplateDefByGuid200Response extends HttpResponse { + status: "200"; + body: TermTemplateDefOutput; +} + +export interface TypeGetTermTemplateDefByGuidDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} + +/** The request has succeeded. */ +export interface TypeGetTermTemplateDefByName200Response extends HttpResponse { + status: "200"; + body: TermTemplateDefOutput; +} + +export interface TypeGetTermTemplateDefByNameDefaultResponse + extends HttpResponse { + status: string; + body: AtlasErrorResponseOutput; +} diff --git a/sdk/purview/purview-datamap-rest/src/serializeHelper.ts b/sdk/purview/purview-datamap-rest/src/serializeHelper.ts new file mode 100644 index 000000000000..710a5bf2a759 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/src/serializeHelper.ts @@ -0,0 +1,13 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +export function buildMultiCollection(items: string[], parameterName: string) { + return items + .map((item, index) => { + if (index === 0) { + return item; + } + return `${parameterName}=${item}`; + }) + .join("&"); +} diff --git a/sdk/purview/purview-datamap-rest/test/public/sampleTest.spec.ts b/sdk/purview/purview-datamap-rest/test/public/sampleTest.spec.ts new file mode 100644 index 000000000000..bce68e428645 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/test/public/sampleTest.spec.ts @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import { Recorder } from "@azure-tools/test-recorder"; +import { assert } from "chai"; +import { createRecorder } from "./utils/recordedClient"; +import { Context } from "mocha"; + +describe("My test", () => { + let recorder: Recorder; + + beforeEach(async function (this: Context) { + recorder = await createRecorder(this); + }); + + afterEach(async function () { + await recorder.stop(); + }); + + it("sample test", async function () { + assert.equal(1, 1); + }); +}); diff --git a/sdk/purview/purview-datamap-rest/test/public/utils/env.browser.ts b/sdk/purview/purview-datamap-rest/test/public/utils/env.browser.ts new file mode 100644 index 000000000000..fd2aca680c7b --- /dev/null +++ b/sdk/purview/purview-datamap-rest/test/public/utils/env.browser.ts @@ -0,0 +1,2 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. diff --git a/sdk/purview/purview-datamap-rest/test/public/utils/env.ts b/sdk/purview/purview-datamap-rest/test/public/utils/env.ts new file mode 100644 index 000000000000..0e06855b73ae --- /dev/null +++ b/sdk/purview/purview-datamap-rest/test/public/utils/env.ts @@ -0,0 +1,6 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import * as dotenv from "dotenv"; + +dotenv.config(); diff --git a/sdk/purview/purview-datamap-rest/test/public/utils/recordedClient.ts b/sdk/purview/purview-datamap-rest/test/public/utils/recordedClient.ts new file mode 100644 index 000000000000..6cc58bc15e11 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/test/public/utils/recordedClient.ts @@ -0,0 +1,29 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +import { Context } from "mocha"; +import { Recorder, RecorderStartOptions } from "@azure-tools/test-recorder"; +import "./env"; + +const envSetupForPlayback: Record = { + ENDPOINT: "https://endpoint", + AZURE_CLIENT_ID: "azure_client_id", + AZURE_CLIENT_SECRET: "azure_client_secret", + AZURE_TENANT_ID: "88888888-8888-8888-8888-888888888888", + SUBSCRIPTION_ID: "azure_subscription_id", +}; + +const recorderEnvSetup: RecorderStartOptions = { + envSetupForPlayback, +}; + +/** + * creates the recorder and reads the environment variables from the `.env` file. + * Should be called first in the test suite to make sure environment variables are + * read before they are being used. + */ +export async function createRecorder(context: Context): Promise { + const recorder = new Recorder(context.currentTest); + await recorder.start(recorderEnvSetup); + return recorder; +} diff --git a/sdk/purview/purview-datamap-rest/tsconfig.json b/sdk/purview/purview-datamap-rest/tsconfig.json new file mode 100644 index 000000000000..d5bf593423c9 --- /dev/null +++ b/sdk/purview/purview-datamap-rest/tsconfig.json @@ -0,0 +1,11 @@ +{ + "extends": "../../../tsconfig.package", + "compilerOptions": { + "outDir": "./dist-esm", + "declarationDir": "./types" + }, + "include": [ + "src/**/*.ts", + "./test/**/*.ts" + ] +} \ No newline at end of file diff --git a/sdk/purview/purview-datamap-rest/tsp-location.yaml b/sdk/purview/purview-datamap-rest/tsp-location.yaml new file mode 100644 index 000000000000..d989d538e91f --- /dev/null +++ b/sdk/purview/purview-datamap-rest/tsp-location.yaml @@ -0,0 +1,5 @@ +directory: specification/purview/Azure.Analytics.Purview.DataMap +commit: 3402ed6263270a5bf8a7375b87d8f8cbb4ab17a9 +additionalDirectories: [] +repo: Azure/azure-rest-api-specs +