@aws-sdk/client-observabilityadmin 3.858.0 → 3.862.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,8 +1,64 @@
 import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, take, withBaseException, } from "@smithy/smithy-client";
-import { AccessDeniedException, InternalServerException, ValidationException, } from "../models/models_0";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, take, withBaseException, } from "@smithy/smithy-client";
+import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, TooManyRequestsException, ValidationException, } from "../models/models_0";
 import { ObservabilityAdminServiceException as __BaseException } from "../models/ObservabilityAdminServiceException";
+export const se_CreateTelemetryRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/CreateTelemetryRule");
+    let body;
+    body = JSON.stringify(take(input, {
+        Rule: (_) => _json(_),
+        RuleName: [],
+        Tags: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_CreateTelemetryRuleForOrganizationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/CreateTelemetryRuleForOrganization");
+    let body;
+    body = JSON.stringify(take(input, {
+        Rule: (_) => _json(_),
+        RuleName: [],
+        Tags: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_DeleteTelemetryRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/DeleteTelemetryRule");
+    let body;
+    body = JSON.stringify(take(input, {
+        RuleIdentifier: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_DeleteTelemetryRuleForOrganizationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/DeleteTelemetryRuleForOrganization");
+    let body;
+    body = JSON.stringify(take(input, {
+        RuleIdentifier: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_GetTelemetryEvaluationStatusCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -19,6 +75,32 @@ export const se_GetTelemetryEvaluationStatusForOrganizationCommand = async (inpu
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_GetTelemetryRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/GetTelemetryRule");
+    let body;
+    body = JSON.stringify(take(input, {
+        RuleIdentifier: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_GetTelemetryRuleForOrganizationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/GetTelemetryRuleForOrganization");
+    let body;
+    body = JSON.stringify(take(input, {
+        RuleIdentifier: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_ListResourceTelemetryCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -56,6 +138,51 @@ export const se_ListResourceTelemetryForOrganizationCommand = async (input, cont
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_ListTagsForResourceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/ListTagsForResource");
+    let body;
+    body = JSON.stringify(take(input, {
+        ResourceARN: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ListTelemetryRulesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/ListTelemetryRules");
+    let body;
+    body = JSON.stringify(take(input, {
+        MaxResults: [],
+        NextToken: [],
+        RuleNamePrefix: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_ListTelemetryRulesForOrganizationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/ListTelemetryRulesForOrganization");
+    let body;
+    body = JSON.stringify(take(input, {
+        MaxResults: [],
+        NextToken: [],
+        RuleNamePrefix: [],
+        SourceAccountIds: (_) => _json(_),
+        SourceOrganizationUnitIds: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_StartTelemetryEvaluationCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -88,6 +215,110 @@ export const se_StopTelemetryEvaluationForOrganizationCommand = async (input, co
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_TagResourceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/TagResource");
+    let body;
+    body = JSON.stringify(take(input, {
+        ResourceARN: [],
+        Tags: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_UntagResourceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/UntagResource");
+    let body;
+    body = JSON.stringify(take(input, {
+        ResourceARN: [],
+        TagKeys: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_UpdateTelemetryRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/UpdateTelemetryRule");
+    let body;
+    body = JSON.stringify(take(input, {
+        Rule: (_) => _json(_),
+        RuleIdentifier: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_UpdateTelemetryRuleForOrganizationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/UpdateTelemetryRuleForOrganization");
+    let body;
+    body = JSON.stringify(take(input, {
+        Rule: (_) => _json(_),
+        RuleIdentifier: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const de_CreateTelemetryRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        RuleArn: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateTelemetryRuleForOrganizationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        RuleArn: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_DeleteTelemetryRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_DeleteTelemetryRuleForOrganizationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_GetTelemetryEvaluationStatusCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -118,6 +349,42 @@ export const de_GetTelemetryEvaluationStatusForOrganizationCommand = async (outp
     Object.assign(contents, doc);
     return contents;
 };
+export const de_GetTelemetryRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        CreatedTimeStamp: __expectLong,
+        LastUpdateTimeStamp: __expectLong,
+        RuleArn: __expectString,
+        RuleName: __expectString,
+        TelemetryRule: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetTelemetryRuleForOrganizationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        CreatedTimeStamp: __expectLong,
+        LastUpdateTimeStamp: __expectLong,
+        RuleArn: __expectString,
+        RuleName: __expectString,
+        TelemetryRule: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_ListResourceTelemetryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -148,6 +415,50 @@ export const de_ListResourceTelemetryForOrganizationCommand = async (output, con
     Object.assign(contents, doc);
     return contents;
 };
+export const de_ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        Tags: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListTelemetryRulesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        NextToken: __expectString,
+        TelemetryRuleSummaries: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListTelemetryRulesForOrganizationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        NextToken: __expectString,
+        TelemetryRuleSummaries: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_StartTelemetryEvaluationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -188,6 +499,54 @@ export const de_StopTelemetryEvaluationForOrganizationCommand = async (output, c
     await collectBody(output.body, context);
     return contents;
 };
+export const de_TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_UpdateTelemetryRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        RuleArn: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_UpdateTelemetryRuleForOrganizationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        RuleArn: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -198,12 +557,24 @@ const de_CommandError = async (output, context) => {
         case "AccessDeniedException":
         case "com.amazonaws.observabilityadmin#AccessDeniedException":
             throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.observabilityadmin#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.observabilityadmin#InternalServerException":
             throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.observabilityadmin#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.observabilityadmin#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.observabilityadmin#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.observabilityadmin#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -229,6 +600,19 @@ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_InternalServerExceptionRes = async (parsedOutput, context) => {
     const contents = map({
         [_aET]: [, parsedOutput.headers[_xae]],
@@ -244,6 +628,47 @@ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = map({
+        [_aET]: [, parsedOutput.headers[_xae]],
+    });
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new TooManyRequestsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;

package/dist-types/ObservabilityAdmin.d.ts

@@ -1,14 +1,51 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
+import { CreateTelemetryRuleCommandInput, CreateTelemetryRuleCommandOutput } from "./commands/CreateTelemetryRuleCommand";
+import { CreateTelemetryRuleForOrganizationCommandInput, CreateTelemetryRuleForOrganizationCommandOutput } from "./commands/CreateTelemetryRuleForOrganizationCommand";
+import { DeleteTelemetryRuleCommandInput, DeleteTelemetryRuleCommandOutput } from "./commands/DeleteTelemetryRuleCommand";
+import { DeleteTelemetryRuleForOrganizationCommandInput, DeleteTelemetryRuleForOrganizationCommandOutput } from "./commands/DeleteTelemetryRuleForOrganizationCommand";
 import { GetTelemetryEvaluationStatusCommandInput, GetTelemetryEvaluationStatusCommandOutput } from "./commands/GetTelemetryEvaluationStatusCommand";
 import { GetTelemetryEvaluationStatusForOrganizationCommandInput, GetTelemetryEvaluationStatusForOrganizationCommandOutput } from "./commands/GetTelemetryEvaluationStatusForOrganizationCommand";
+import { GetTelemetryRuleCommandInput, GetTelemetryRuleCommandOutput } from "./commands/GetTelemetryRuleCommand";
+import { GetTelemetryRuleForOrganizationCommandInput, GetTelemetryRuleForOrganizationCommandOutput } from "./commands/GetTelemetryRuleForOrganizationCommand";
 import { ListResourceTelemetryCommandInput, ListResourceTelemetryCommandOutput } from "./commands/ListResourceTelemetryCommand";
 import { ListResourceTelemetryForOrganizationCommandInput, ListResourceTelemetryForOrganizationCommandOutput } from "./commands/ListResourceTelemetryForOrganizationCommand";
+import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
+import { ListTelemetryRulesCommandInput, ListTelemetryRulesCommandOutput } from "./commands/ListTelemetryRulesCommand";
+import { ListTelemetryRulesForOrganizationCommandInput, ListTelemetryRulesForOrganizationCommandOutput } from "./commands/ListTelemetryRulesForOrganizationCommand";
 import { StartTelemetryEvaluationCommandInput, StartTelemetryEvaluationCommandOutput } from "./commands/StartTelemetryEvaluationCommand";
 import { StartTelemetryEvaluationForOrganizationCommandInput, StartTelemetryEvaluationForOrganizationCommandOutput } from "./commands/StartTelemetryEvaluationForOrganizationCommand";
 import { StopTelemetryEvaluationCommandInput, StopTelemetryEvaluationCommandOutput } from "./commands/StopTelemetryEvaluationCommand";
 import { StopTelemetryEvaluationForOrganizationCommandInput, StopTelemetryEvaluationForOrganizationCommandOutput } from "./commands/StopTelemetryEvaluationForOrganizationCommand";
+import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
+import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
+import { UpdateTelemetryRuleCommandInput, UpdateTelemetryRuleCommandOutput } from "./commands/UpdateTelemetryRuleCommand";
+import { UpdateTelemetryRuleForOrganizationCommandInput, UpdateTelemetryRuleForOrganizationCommandOutput } from "./commands/UpdateTelemetryRuleForOrganizationCommand";
 import { ObservabilityAdminClient } from "./ObservabilityAdminClient";
 export interface ObservabilityAdmin {
+    /**
+     * @see {@link CreateTelemetryRuleCommand}
+     */
+    createTelemetryRule(args: CreateTelemetryRuleCommandInput, options?: __HttpHandlerOptions): Promise<CreateTelemetryRuleCommandOutput>;
+    createTelemetryRule(args: CreateTelemetryRuleCommandInput, cb: (err: any, data?: CreateTelemetryRuleCommandOutput) => void): void;
+    createTelemetryRule(args: CreateTelemetryRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateTelemetryRuleCommandOutput) => void): void;
+    /**
+     * @see {@link CreateTelemetryRuleForOrganizationCommand}
+     */
+    createTelemetryRuleForOrganization(args: CreateTelemetryRuleForOrganizationCommandInput, options?: __HttpHandlerOptions): Promise<CreateTelemetryRuleForOrganizationCommandOutput>;
+    createTelemetryRuleForOrganization(args: CreateTelemetryRuleForOrganizationCommandInput, cb: (err: any, data?: CreateTelemetryRuleForOrganizationCommandOutput) => void): void;
+    createTelemetryRuleForOrganization(args: CreateTelemetryRuleForOrganizationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateTelemetryRuleForOrganizationCommandOutput) => void): void;
+    /**
+     * @see {@link DeleteTelemetryRuleCommand}
+     */
+    deleteTelemetryRule(args: DeleteTelemetryRuleCommandInput, options?: __HttpHandlerOptions): Promise<DeleteTelemetryRuleCommandOutput>;
+    deleteTelemetryRule(args: DeleteTelemetryRuleCommandInput, cb: (err: any, data?: DeleteTelemetryRuleCommandOutput) => void): void;
+    deleteTelemetryRule(args: DeleteTelemetryRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteTelemetryRuleCommandOutput) => void): void;
+    /**
+     * @see {@link DeleteTelemetryRuleForOrganizationCommand}
+     */
+    deleteTelemetryRuleForOrganization(args: DeleteTelemetryRuleForOrganizationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteTelemetryRuleForOrganizationCommandOutput>;
+    deleteTelemetryRuleForOrganization(args: DeleteTelemetryRuleForOrganizationCommandInput, cb: (err: any, data?: DeleteTelemetryRuleForOrganizationCommandOutput) => void): void;
+    deleteTelemetryRuleForOrganization(args: DeleteTelemetryRuleForOrganizationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteTelemetryRuleForOrganizationCommandOutput) => void): void;
     /**
      * @see {@link GetTelemetryEvaluationStatusCommand}
      */
@@ -23,6 +60,18 @@ export interface ObservabilityAdmin {
     getTelemetryEvaluationStatusForOrganization(args: GetTelemetryEvaluationStatusForOrganizationCommandInput, options?: __HttpHandlerOptions): Promise<GetTelemetryEvaluationStatusForOrganizationCommandOutput>;
     getTelemetryEvaluationStatusForOrganization(args: GetTelemetryEvaluationStatusForOrganizationCommandInput, cb: (err: any, data?: GetTelemetryEvaluationStatusForOrganizationCommandOutput) => void): void;
     getTelemetryEvaluationStatusForOrganization(args: GetTelemetryEvaluationStatusForOrganizationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetTelemetryEvaluationStatusForOrganizationCommandOutput) => void): void;
+    /**
+     * @see {@link GetTelemetryRuleCommand}
+     */
+    getTelemetryRule(args: GetTelemetryRuleCommandInput, options?: __HttpHandlerOptions): Promise<GetTelemetryRuleCommandOutput>;
+    getTelemetryRule(args: GetTelemetryRuleCommandInput, cb: (err: any, data?: GetTelemetryRuleCommandOutput) => void): void;
+    getTelemetryRule(args: GetTelemetryRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetTelemetryRuleCommandOutput) => void): void;
+    /**
+     * @see {@link GetTelemetryRuleForOrganizationCommand}
+     */
+    getTelemetryRuleForOrganization(args: GetTelemetryRuleForOrganizationCommandInput, options?: __HttpHandlerOptions): Promise<GetTelemetryRuleForOrganizationCommandOutput>;
+    getTelemetryRuleForOrganization(args: GetTelemetryRuleForOrganizationCommandInput, cb: (err: any, data?: GetTelemetryRuleForOrganizationCommandOutput) => void): void;
+    getTelemetryRuleForOrganization(args: GetTelemetryRuleForOrganizationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetTelemetryRuleForOrganizationCommandOutput) => void): void;
     /**
      * @see {@link ListResourceTelemetryCommand}
      */
@@ -37,6 +86,26 @@ export interface ObservabilityAdmin {
     listResourceTelemetryForOrganization(args: ListResourceTelemetryForOrganizationCommandInput, options?: __HttpHandlerOptions): Promise<ListResourceTelemetryForOrganizationCommandOutput>;
     listResourceTelemetryForOrganization(args: ListResourceTelemetryForOrganizationCommandInput, cb: (err: any, data?: ListResourceTelemetryForOrganizationCommandOutput) => void): void;
     listResourceTelemetryForOrganization(args: ListResourceTelemetryForOrganizationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListResourceTelemetryForOrganizationCommandOutput) => void): void;
+    /**
+     * @see {@link ListTagsForResourceCommand}
+     */
+    listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
+    listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
+    listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
+    /**
+     * @see {@link ListTelemetryRulesCommand}
+     */
+    listTelemetryRules(): Promise<ListTelemetryRulesCommandOutput>;
+    listTelemetryRules(args: ListTelemetryRulesCommandInput, options?: __HttpHandlerOptions): Promise<ListTelemetryRulesCommandOutput>;
+    listTelemetryRules(args: ListTelemetryRulesCommandInput, cb: (err: any, data?: ListTelemetryRulesCommandOutput) => void): void;
+    listTelemetryRules(args: ListTelemetryRulesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTelemetryRulesCommandOutput) => void): void;
+    /**
+     * @see {@link ListTelemetryRulesForOrganizationCommand}
+     */
+    listTelemetryRulesForOrganization(): Promise<ListTelemetryRulesForOrganizationCommandOutput>;
+    listTelemetryRulesForOrganization(args: ListTelemetryRulesForOrganizationCommandInput, options?: __HttpHandlerOptions): Promise<ListTelemetryRulesForOrganizationCommandOutput>;
+    listTelemetryRulesForOrganization(args: ListTelemetryRulesForOrganizationCommandInput, cb: (err: any, data?: ListTelemetryRulesForOrganizationCommandOutput) => void): void;
+    listTelemetryRulesForOrganization(args: ListTelemetryRulesForOrganizationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTelemetryRulesForOrganizationCommandOutput) => void): void;
     /**
      * @see {@link StartTelemetryEvaluationCommand}
      */
@@ -65,10 +134,34 @@ export interface ObservabilityAdmin {
     stopTelemetryEvaluationForOrganization(args: StopTelemetryEvaluationForOrganizationCommandInput, options?: __HttpHandlerOptions): Promise<StopTelemetryEvaluationForOrganizationCommandOutput>;
     stopTelemetryEvaluationForOrganization(args: StopTelemetryEvaluationForOrganizationCommandInput, cb: (err: any, data?: StopTelemetryEvaluationForOrganizationCommandOutput) => void): void;
     stopTelemetryEvaluationForOrganization(args: StopTelemetryEvaluationForOrganizationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StopTelemetryEvaluationForOrganizationCommandOutput) => void): void;
+    /**
+     * @see {@link TagResourceCommand}
+     */
+    tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
+    tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
+    tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
+    /**
+     * @see {@link UntagResourceCommand}
+     */
+    untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
+    untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
+    untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateTelemetryRuleCommand}
+     */
+    updateTelemetryRule(args: UpdateTelemetryRuleCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTelemetryRuleCommandOutput>;
+    updateTelemetryRule(args: UpdateTelemetryRuleCommandInput, cb: (err: any, data?: UpdateTelemetryRuleCommandOutput) => void): void;
+    updateTelemetryRule(args: UpdateTelemetryRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateTelemetryRuleCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateTelemetryRuleForOrganizationCommand}
+     */
+    updateTelemetryRuleForOrganization(args: UpdateTelemetryRuleForOrganizationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateTelemetryRuleForOrganizationCommandOutput>;
+    updateTelemetryRuleForOrganization(args: UpdateTelemetryRuleForOrganizationCommandInput, cb: (err: any, data?: UpdateTelemetryRuleForOrganizationCommandOutput) => void): void;
+    updateTelemetryRuleForOrganization(args: UpdateTelemetryRuleForOrganizationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateTelemetryRuleForOrganizationCommandOutput) => void): void;
 }
 /**
  * <p>
- *       Amazon CloudWatch Obsersavability Admin to control temletry config for your AWS Organization or account. Telemetry config config to discover and understand the state of telemetry configuration for your AWS resources from a central view in the CloudWatch console. Telemetry config simplifies the process of auditing your telemetry collection configurations across multiple resource types across your AWS Organization or account.
+ *       You can use Amazon CloudWatch Observability Admin to discover and understand the state of telemetry configuration in CloudWatch for your Amazon Web Services Organization or account. This simplifies the process of auditing your telemetry collection configurations across multiple resource types within your Amazon Web Services Organization or account. By providing a consolidated view, it allows you to easily review and manage telemetry settings, helping you ensure proper monitoring and data collection across your Amazon Web Services environment.
  *       For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/telemetry-config-cloudwatch.html">Auditing CloudWatch telemetry configurations</a> in the CloudWatch User Guide.</p>
  *          <p>For information on the permissions you need to use this API, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/auth-and-access-control-cw.html">Identity and access management for Amazon CloudWatch</a> in the CloudWatch User Guide.</p>
  * @public