@azure/ai-content-understanding 1.0.0

package/dist/browser/api/index.js

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export { createContentUnderstanding, } from "./contentUnderstandingContext.js";
+export { updateDefaults, updateAnalyzer, listAnalyzers, grantCopyAuthorization, getResultFile, getResult, getOperationStatus, getDefaults, getAnalyzer, deleteResult, deleteAnalyzer, createAnalyzer, copyAnalyzer, analyzeBinary, analyze, } from "./operations.js";
+//# sourceMappingURL=index.js.map

package/dist/browser/api/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,OAAO,EACL,0BAA0B,GAG3B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,cAAc,EACd,cAAc,EACd,aAAa,EACb,sBAAsB,EACtB,aAAa,EACb,SAAS,EACT,kBAAkB,EAClB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,cAAc,EACd,cAAc,EACd,YAAY,EACZ,aAAa,EACb,OAAO,GACR,MAAM,iBAAiB,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nexport {\n  createContentUnderstanding,\n  ContentUnderstandingContext,\n  ContentUnderstandingClientOptionalParams,\n} from \"./contentUnderstandingContext.js\";\nexport {\n  updateDefaults,\n  updateAnalyzer,\n  listAnalyzers,\n  grantCopyAuthorization,\n  getResultFile,\n  getResult,\n  getOperationStatus,\n  getDefaults,\n  getAnalyzer,\n  deleteResult,\n  deleteAnalyzer,\n  createAnalyzer,\n  copyAnalyzer,\n  analyzeBinary,\n  analyze,\n} from \"./operations.js\";\nexport {\n  UpdateDefaultsOptionalParams,\n  UpdateAnalyzerOptionalParams,\n  ListAnalyzersOptionalParams,\n  GrantCopyAuthorizationOptionalParams,\n  GetResultFileOptionalParams,\n  GetResultOptionalParams,\n  GetOperationStatusOptionalParams,\n  GetDefaultsOptionalParams,\n  GetAnalyzerOptionalParams,\n  DeleteResultOptionalParams,\n  DeleteAnalyzerOptionalParams,\n  CreateAnalyzerOptionalParams,\n  CopyAnalyzerOptionalParams,\n  AnalyzeBinaryOptionalParams,\n  AnalyzeOptionalParams,\n} from \"./options.js\";\n"]}

package/dist/browser/api/operations.d.ts

@@ -0,0 +1,67 @@
+import type { ContentUnderstandingContext as Client } from "./index.js";
+import type { AnalysisInput, AnalysisResult, ContentAnalyzerAnalyzeOperationStatus, ContentAnalyzer, ContentAnalyzerOperationStatus, ContentUnderstandingDefaults, CopyAuthorization, _PagedContentAnalyzer } from "../models/models.js";
+import type { PagedAsyncIterableIterator } from "../static-helpers/pagingHelpers.js";
+import type { UpdateDefaultsOptionalParams, UpdateAnalyzerOptionalParams, ListAnalyzersOptionalParams, GrantCopyAuthorizationOptionalParams, GetResultFileOptionalParams, GetResultOptionalParams, GetOperationStatusOptionalParams, GetDefaultsOptionalParams, GetAnalyzerOptionalParams, DeleteResultOptionalParams, DeleteAnalyzerOptionalParams, CreateAnalyzerOptionalParams, CopyAnalyzerOptionalParams, AnalyzeBinaryOptionalParams, AnalyzeOptionalParams } from "./options.js";
+import type { StreamableMethod, PathUncheckedResponse } from "@azure-rest/core-client";
+import type { PollerLike, OperationState } from "@azure/core-lro";
+export declare function _updateDefaultsSend(context: Client, options?: UpdateDefaultsOptionalParams): StreamableMethod;
+export declare function _updateDefaultsDeserialize(result: PathUncheckedResponse): Promise<ContentUnderstandingDefaults>;
+/** Update default settings for this Content Understanding resource. */
+export declare function updateDefaults(context: Client, options?: UpdateDefaultsOptionalParams): Promise<ContentUnderstandingDefaults>;
+export declare function _updateAnalyzerSend(context: Client, analyzerId: string, resource: ContentAnalyzer, options?: UpdateAnalyzerOptionalParams): StreamableMethod;
+export declare function _updateAnalyzerDeserialize(result: PathUncheckedResponse): Promise<ContentAnalyzer>;
+/** Update analyzer properties. */
+export declare function updateAnalyzer(context: Client, analyzerId: string, resource: ContentAnalyzer, options?: UpdateAnalyzerOptionalParams): Promise<ContentAnalyzer>;
+export declare function _listAnalyzersSend(context: Client, options?: ListAnalyzersOptionalParams): StreamableMethod;
+export declare function _listAnalyzersDeserialize(result: PathUncheckedResponse): Promise<_PagedContentAnalyzer>;
+/** List analyzers. */
+export declare function listAnalyzers(context: Client, options?: ListAnalyzersOptionalParams): PagedAsyncIterableIterator<ContentAnalyzer>;
+export declare function _grantCopyAuthorizationSend(context: Client, analyzerId: string, targetAzureResourceId: string, options?: GrantCopyAuthorizationOptionalParams): StreamableMethod;
+export declare function _grantCopyAuthorizationDeserialize(result: PathUncheckedResponse): Promise<CopyAuthorization>;
+/** Get authorization for copying this analyzer to another location. */
+export declare function grantCopyAuthorization(context: Client, analyzerId: string, targetAzureResourceId: string, options?: GrantCopyAuthorizationOptionalParams): Promise<CopyAuthorization>;
+export declare function _getResultFileSend(context: Client, operationId: string, path: string, options?: GetResultFileOptionalParams): StreamableMethod;
+export declare function _getResultFileDeserialize(result: PathUncheckedResponse): Promise<Uint8Array>;
+/** Get a file associated with the result of an analysis operation. */
+export declare function getResultFile(context: Client, operationId: string, path: string, options?: GetResultFileOptionalParams): Promise<Uint8Array>;
+export declare function _getResultSend(context: Client, operationId: string, options?: GetResultOptionalParams): StreamableMethod;
+export declare function _getResultDeserialize(result: PathUncheckedResponse): Promise<ContentAnalyzerAnalyzeOperationStatus>;
+/** Get the result of an analysis operation. */
+export declare function getResult(context: Client, operationId: string, options?: GetResultOptionalParams): Promise<ContentAnalyzerAnalyzeOperationStatus>;
+export declare function _getOperationStatusSend(context: Client, analyzerId: string, operationId: string, options?: GetOperationStatusOptionalParams): StreamableMethod;
+export declare function _getOperationStatusDeserialize(result: PathUncheckedResponse): Promise<ContentAnalyzerOperationStatus>;
+/** Get the status of an analyzer creation operation. */
+export declare function getOperationStatus(context: Client, analyzerId: string, operationId: string, options?: GetOperationStatusOptionalParams): Promise<ContentAnalyzerOperationStatus>;
+export declare function _getDefaultsSend(context: Client, options?: GetDefaultsOptionalParams): StreamableMethod;
+export declare function _getDefaultsDeserialize(result: PathUncheckedResponse): Promise<ContentUnderstandingDefaults>;
+/** Return default settings for this Content Understanding resource. */
+export declare function getDefaults(context: Client, options?: GetDefaultsOptionalParams): Promise<ContentUnderstandingDefaults>;
+export declare function _getAnalyzerSend(context: Client, analyzerId: string, options?: GetAnalyzerOptionalParams): StreamableMethod;
+export declare function _getAnalyzerDeserialize(result: PathUncheckedResponse): Promise<ContentAnalyzer>;
+/** Get analyzer properties. */
+export declare function getAnalyzer(context: Client, analyzerId: string, options?: GetAnalyzerOptionalParams): Promise<ContentAnalyzer>;
+export declare function _deleteResultSend(context: Client, operationId: string, options?: DeleteResultOptionalParams): StreamableMethod;
+export declare function _deleteResultDeserialize(result: PathUncheckedResponse): Promise<void>;
+/** Mark the result of an analysis operation for deletion. */
+export declare function deleteResult(context: Client, operationId: string, options?: DeleteResultOptionalParams): Promise<void>;
+export declare function _deleteAnalyzerSend(context: Client, analyzerId: string, options?: DeleteAnalyzerOptionalParams): StreamableMethod;
+export declare function _deleteAnalyzerDeserialize(result: PathUncheckedResponse): Promise<void>;
+/** Delete analyzer. */
+export declare function deleteAnalyzer(context: Client, analyzerId: string, options?: DeleteAnalyzerOptionalParams): Promise<void>;
+export declare function _createAnalyzerSend(context: Client, analyzerId: string, resource: ContentAnalyzer, options?: CreateAnalyzerOptionalParams): StreamableMethod;
+export declare function _createAnalyzerDeserialize(result: PathUncheckedResponse): Promise<ContentAnalyzer>;
+/** Create a new analyzer asynchronously. */
+export declare function createAnalyzer(context: Client, analyzerId: string, resource: ContentAnalyzer, options?: CreateAnalyzerOptionalParams): PollerLike<OperationState<ContentAnalyzer>, ContentAnalyzer>;
+export declare function _copyAnalyzerSend(context: Client, analyzerId: string, sourceAnalyzerId: string, options?: CopyAnalyzerOptionalParams): StreamableMethod;
+export declare function _copyAnalyzerDeserialize(result: PathUncheckedResponse): Promise<ContentAnalyzer>;
+/** Create a copy of the source analyzer to the current location. */
+export declare function copyAnalyzer(context: Client, analyzerId: string, sourceAnalyzerId: string, options?: CopyAnalyzerOptionalParams): PollerLike<OperationState<ContentAnalyzer>, ContentAnalyzer>;
+export declare function _analyzeBinarySend(context: Client, analyzerId: string, input: Uint8Array, contentType: string, options?: AnalyzeBinaryOptionalParams): StreamableMethod;
+export declare function _analyzeBinaryDeserialize(result: PathUncheckedResponse): Promise<AnalysisResult>;
+/** Extract content and fields from input. */
+export declare function analyzeBinary(context: Client, analyzerId: string, input: Uint8Array, contentType: string, options?: AnalyzeBinaryOptionalParams): PollerLike<OperationState<AnalysisResult>, AnalysisResult>;
+export declare function _analyzeSend(context: Client, analyzerId: string, inputs: AnalysisInput[], options?: AnalyzeOptionalParams): StreamableMethod;
+export declare function _analyzeDeserialize(result: PathUncheckedResponse): Promise<AnalysisResult>;
+/** Extract content and fields from input. */
+export declare function analyze(context: Client, analyzerId: string, inputs: AnalysisInput[], options?: AnalyzeOptionalParams): PollerLike<OperationState<AnalysisResult>, AnalysisResult>;
+//# sourceMappingURL=operations.d.ts.map

package/dist/browser/api/operations.js

@@ -0,0 +1,488 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { analysisInputArraySerializer, analysisResultDeserializer, contentAnalyzerAnalyzeOperationStatusDeserializer, contentAnalyzerSerializer, contentAnalyzerDeserializer, contentAnalyzerOperationStatusDeserializer, contentUnderstandingDefaultsDeserializer, copyAuthorizationDeserializer, recordMergePatchUpdateSerializer, _pagedContentAnalyzerDeserializer, } from "../models/models.js";
+import { buildPagedAsyncIterator } from "../static-helpers/pagingHelpers.js";
+import { getLongRunningPoller } from "../static-helpers/pollingHelpers.js";
+import { getBinaryResponse } from "../static-helpers/serialization/get-binary-response.js";
+import { expandUrlTemplate } from "../static-helpers/urlTemplate.js";
+import { createRestError, operationOptionsToRequestParameters } from "@azure-rest/core-client";
+export function _updateDefaultsSend(context, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/defaults{?api%2Dversion}", {
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).patch({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/merge-patch+json",
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+        body: {
+            modelDeployments: !options?.modelDeployments
+                ? options?.modelDeployments
+                : recordMergePatchUpdateSerializer(options?.modelDeployments),
+        },
+    });
+}
+export async function _updateDefaultsDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return contentUnderstandingDefaultsDeserializer(result.body);
+}
+/** Update default settings for this Content Understanding resource. */
+export async function updateDefaults(context, options = { requestOptions: {} }) {
+    const result = await _updateDefaultsSend(context, options);
+    return _updateDefaultsDeserialize(result);
+}
+export function _updateAnalyzerSend(context, analyzerId, resource, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}{?api%2Dversion}", {
+        analyzerId: analyzerId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).patch({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/merge-patch+json",
+        headers: {
+            ...(options?.clientRequestId !== undefined
+                ? { "x-ms-client-request-id": options?.clientRequestId }
+                : {}),
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: contentAnalyzerSerializer(resource),
+    });
+}
+export async function _updateAnalyzerDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return contentAnalyzerDeserializer(result.body);
+}
+/** Update analyzer properties. */
+export async function updateAnalyzer(context, analyzerId, resource, options = { requestOptions: {} }) {
+    const result = await _updateAnalyzerSend(context, analyzerId, resource, options);
+    return _updateAnalyzerDeserialize(result);
+}
+export function _listAnalyzersSend(context, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers{?api%2Dversion}", {
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            ...(options?.clientRequestId !== undefined
+                ? { "x-ms-client-request-id": options?.clientRequestId }
+                : {}),
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _listAnalyzersDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return _pagedContentAnalyzerDeserializer(result.body);
+}
+/** List analyzers. */
+export function listAnalyzers(context, options = { requestOptions: {} }) {
+    return buildPagedAsyncIterator(context, () => _listAnalyzersSend(context, options), _listAnalyzersDeserialize, ["200"], { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion ?? "2025-11-01" });
+}
+export function _grantCopyAuthorizationSend(context, analyzerId, targetAzureResourceId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}:grantCopyAuthorization{?api%2Dversion}", {
+        analyzerId: analyzerId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            ...(options?.clientRequestId !== undefined
+                ? { "x-ms-client-request-id": options?.clientRequestId }
+                : {}),
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: { targetAzureResourceId: targetAzureResourceId, targetRegion: options?.targetRegion },
+    });
+}
+export async function _grantCopyAuthorizationDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return copyAuthorizationDeserializer(result.body);
+}
+/** Get authorization for copying this analyzer to another location. */
+export async function grantCopyAuthorization(context, analyzerId, targetAzureResourceId, options = { requestOptions: {} }) {
+    const result = await _grantCopyAuthorizationSend(context, analyzerId, targetAzureResourceId, options);
+    return _grantCopyAuthorizationDeserialize(result);
+}
+export function _getResultFileSend(context, operationId, path, options = { requestOptions: {} }) {
+    // CUSTOMIZATION: EMITTER-FIX: Renamed `path` to `urlPath` to avoid shadowing the function parameter `path`
+    const urlPath = expandUrlTemplate("/analyzerResults/{operationId}/files/{+path}{?api%2Dversion}", {
+        operationId: operationId,
+        path: path,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(urlPath).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "*/*", ...options.requestOptions?.headers },
+    });
+}
+export async function _getResultFileDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return result.body;
+}
+/** Get a file associated with the result of an analysis operation. */
+export async function getResultFile(context, operationId, path, options = { requestOptions: {} }) {
+    const streamableMethod = _getResultFileSend(context, operationId, path, options);
+    const result = await getBinaryResponse(streamableMethod);
+    return _getResultFileDeserialize(result);
+}
+export function _getResultSend(context, operationId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzerResults/{operationId}{?api%2Dversion}", {
+        operationId: operationId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+    });
+}
+export async function _getResultDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return contentAnalyzerAnalyzeOperationStatusDeserializer(result.body);
+}
+/** Get the result of an analysis operation. */
+export async function getResult(context, operationId, options = { requestOptions: {} }) {
+    const result = await _getResultSend(context, operationId, options);
+    return _getResultDeserialize(result);
+}
+export function _getOperationStatusSend(context, analyzerId, operationId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}/operations/{operationId}{?api%2Dversion}", {
+        analyzerId: analyzerId,
+        operationId: operationId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+    });
+}
+export async function _getOperationStatusDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return contentAnalyzerOperationStatusDeserializer(result.body);
+}
+/** Get the status of an analyzer creation operation. */
+export async function getOperationStatus(context, analyzerId, operationId, options = { requestOptions: {} }) {
+    const result = await _getOperationStatusSend(context, analyzerId, operationId, options);
+    return _getOperationStatusDeserialize(result);
+}
+export function _getDefaultsSend(context, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/defaults{?api%2Dversion}", {
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: { accept: "application/json", ...options.requestOptions?.headers },
+    });
+}
+export async function _getDefaultsDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return contentUnderstandingDefaultsDeserializer(result.body);
+}
+/** Return default settings for this Content Understanding resource. */
+export async function getDefaults(context, options = { requestOptions: {} }) {
+    const result = await _getDefaultsSend(context, options);
+    return _getDefaultsDeserialize(result);
+}
+export function _getAnalyzerSend(context, analyzerId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}{?api%2Dversion}", {
+        analyzerId: analyzerId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).get({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            ...(options?.clientRequestId !== undefined
+                ? { "x-ms-client-request-id": options?.clientRequestId }
+                : {}),
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _getAnalyzerDeserialize(result) {
+    const expectedStatuses = ["200"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return contentAnalyzerDeserializer(result.body);
+}
+/** Get analyzer properties. */
+export async function getAnalyzer(context, analyzerId, options = { requestOptions: {} }) {
+    const result = await _getAnalyzerSend(context, analyzerId, options);
+    return _getAnalyzerDeserialize(result);
+}
+export function _deleteResultSend(context, operationId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzerResults/{operationId}{?api%2Dversion}", {
+        operationId: operationId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).delete({ ...operationOptionsToRequestParameters(options) });
+}
+export async function _deleteResultDeserialize(result) {
+    const expectedStatuses = ["204"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return;
+}
+/** Mark the result of an analysis operation for deletion. */
+export async function deleteResult(context, operationId, options = { requestOptions: {} }) {
+    const result = await _deleteResultSend(context, operationId, options);
+    return _deleteResultDeserialize(result);
+}
+export function _deleteAnalyzerSend(context, analyzerId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}{?api%2Dversion}", {
+        analyzerId: analyzerId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).delete({
+        ...operationOptionsToRequestParameters(options),
+        headers: {
+            ...(options?.clientRequestId !== undefined
+                ? { "x-ms-client-request-id": options?.clientRequestId }
+                : {}),
+            ...options.requestOptions?.headers,
+        },
+    });
+}
+export async function _deleteAnalyzerDeserialize(result) {
+    const expectedStatuses = ["204"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return;
+}
+/** Delete analyzer. */
+export async function deleteAnalyzer(context, analyzerId, options = { requestOptions: {} }) {
+    const result = await _deleteAnalyzerSend(context, analyzerId, options);
+    return _deleteAnalyzerDeserialize(result);
+}
+export function _createAnalyzerSend(context, analyzerId, resource, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}{?api%2Dversion,allowReplace}", {
+        analyzerId: analyzerId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+        allowReplace: options?.allowReplace,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).put({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            ...(options?.clientRequestId !== undefined
+                ? { "x-ms-client-request-id": options?.clientRequestId }
+                : {}),
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: contentAnalyzerSerializer(resource),
+    });
+}
+export async function _createAnalyzerDeserialize(result) {
+    const expectedStatuses = ["201", "200", "202"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    return contentAnalyzerDeserializer(result.body);
+}
+/** Create a new analyzer asynchronously. */
+export function createAnalyzer(context, analyzerId, resource, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _createAnalyzerDeserialize, ["201", "200", "202"], {
+        // CUSTOMIZATION: SDK-IMPROVEMENT: Default polling interval to 3 seconds (generated code defaults to 2 seconds).
+        updateIntervalInMs: options?.updateIntervalInMs ?? 3000,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _createAnalyzerSend(context, analyzerId, resource, options),
+        resourceLocationConfig: "original-uri",
+        apiVersion: context.apiVersion ?? "2025-11-01",
+    });
+}
+export function _copyAnalyzerSend(context, analyzerId, sourceAnalyzerId, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}:copy{?api%2Dversion,allowReplace}", {
+        analyzerId: analyzerId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+        allowReplace: options?.allowReplace,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            ...(options?.clientRequestId !== undefined
+                ? { "x-ms-client-request-id": options?.clientRequestId }
+                : {}),
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: {
+            sourceAzureResourceId: options?.sourceAzureResourceId,
+            sourceRegion: options?.sourceRegion,
+            sourceAnalyzerId: sourceAnalyzerId,
+        },
+    });
+}
+export async function _copyAnalyzerDeserialize(result) {
+    const expectedStatuses = ["201", "200", "202"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    if (result?.body?.result === undefined) {
+        throw createRestError(`Expected a result in the response at position "result.body.result"`, result);
+    }
+    return contentAnalyzerDeserializer(result.body.result);
+}
+/** Create a copy of the source analyzer to the current location. */
+export function copyAnalyzer(context, analyzerId, sourceAnalyzerId, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _copyAnalyzerDeserialize, ["201", "200", "202"], {
+        // CUSTOMIZATION: SDK-IMPROVEMENT: Default polling interval to 3 seconds (generated code defaults to 2 seconds).
+        updateIntervalInMs: options?.updateIntervalInMs ?? 3000,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _copyAnalyzerSend(context, analyzerId, sourceAnalyzerId, options),
+        resourceLocationConfig: "operation-location",
+        apiVersion: context.apiVersion ?? "2025-11-01",
+    });
+}
+// CUSTOMIZATION: SDK-IMPROVEMENT: `_analyzeBinarySend` and `analyzeBinary` signatures differ from generated code:
+// - Generated has: (context, analyzerId, input, stringEncoding, contentType, options)
+// - Custom has: (context, analyzerId, input, contentType, options)
+// `stringEncoding` is removed as a positional param and passed via options instead, so the custom
+// ContentUnderstandingClient can always inject `"utf16"` internally.
+// Also fixes generated bug: `body: binaryInput` (wrong var name, should be `input`).
+export function _analyzeBinarySend(context, analyzerId, input, contentType, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}:analyzeBinary{?api%2Dversion,stringEncoding,processingLocation,range}", {
+        analyzerId: analyzerId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+        stringEncoding: options?.stringEncoding,
+        processingLocation: options?.processingLocation,
+        range: options?.contentRange,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: contentType,
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: input,
+    });
+}
+export async function _analyzeBinaryDeserialize(result) {
+    const expectedStatuses = ["202", "200", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    if (result?.body?.result === undefined) {
+        throw createRestError(`Expected a result in the response at position "result.body.result"`, result);
+    }
+    return analysisResultDeserializer(result.body.result);
+}
+/** Extract content and fields from input. */
+export function analyzeBinary(context, analyzerId, input, contentType, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _analyzeBinaryDeserialize, ["202", "200", "201"], {
+        // CUSTOMIZATION: SDK-IMPROVEMENT: Default polling interval to 3 seconds (generated code defaults to 2 seconds).
+        updateIntervalInMs: options?.updateIntervalInMs ?? 3000,
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _analyzeBinarySend(context, analyzerId, input, contentType, options),
+        resourceLocationConfig: "operation-location",
+        apiVersion: context.apiVersion ?? "2025-11-01",
+    });
+}
+// CUSTOMIZATION: SDK-IMPROVEMENT: `_analyzeSend` and `analyze` signatures differ from generated code:
+// - Generated has: (context, analyzerId, inputs, stringEncoding, options)
+// - Custom has: (context, analyzerId, inputs, options)
+// `stringEncoding` is removed as a positional param and passed via options instead,
+// so the custom ContentUnderstandingClient can always inject `"utf16"` internally.
+export function _analyzeSend(context, analyzerId, inputs, options = { requestOptions: {} }) {
+    const path = expandUrlTemplate("/analyzers/{analyzerId}:analyze{?api%2Dversion,stringEncoding,processingLocation}", {
+        analyzerId: analyzerId,
+        "api%2Dversion": context.apiVersion ?? "2025-11-01",
+        stringEncoding: options?.stringEncoding,
+        processingLocation: options?.processingLocation,
+    }, {
+        allowReserved: options?.requestOptions?.skipUrlEncoding,
+    });
+    return context.path(path).post({
+        ...operationOptionsToRequestParameters(options),
+        contentType: "application/json",
+        headers: {
+            accept: "application/json",
+            ...options.requestOptions?.headers,
+        },
+        body: {
+            inputs: analysisInputArraySerializer(inputs),
+            modelDeployments: options?.modelDeployments,
+        },
+    });
+}
+export async function _analyzeDeserialize(result) {
+    const expectedStatuses = ["202", "200", "201"];
+    if (!expectedStatuses.includes(result.status)) {
+        throw createRestError(result);
+    }
+    if (result?.body?.result === undefined) {
+        throw createRestError(`Expected a result in the response at position "result.body.result"`, result);
+    }
+    return analysisResultDeserializer(result.body.result);
+}
+/** Extract content and fields from input. */
+export function analyze(context, analyzerId, inputs, options = { requestOptions: {} }) {
+    return getLongRunningPoller(context, _analyzeDeserialize, ["202", "200", "201"], {
+        // CUSTOMIZATION: SDK-IMPROVEMENT: Default polling interval to 3 seconds (generated code defaults to 2 seconds).
+        abortSignal: options?.abortSignal,
+        getInitialResponse: () => _analyzeSend(context, analyzerId, inputs, options),
+        resourceLocationConfig: "operation-location",
+        apiVersion: context.apiVersion ?? "2025-11-01",
+    });
+}
+//# sourceMappingURL=operations.js.map