@effect-aws/client-kafka 1.10.6

package/dist/cjs/KafkaService.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaService = exports.makeKafkaService = void 0;
+/**
+ * @since 1.0.0
+ */
+const client_kafka_1 = require("@aws-sdk/client-kafka");
+const commons_1 = require("@effect-aws/commons");
+const effect_1 = require("effect");
+const Errors_js_1 = require("./Errors.js");
+const Instance = __importStar(require("./KafkaClientInstance.js"));
+const KafkaServiceConfig = __importStar(require("./KafkaServiceConfig.js"));
+const commands = {
+    BatchAssociateScramSecretCommand: client_kafka_1.BatchAssociateScramSecretCommand,
+    BatchDisassociateScramSecretCommand: client_kafka_1.BatchDisassociateScramSecretCommand,
+    CreateClusterCommand: client_kafka_1.CreateClusterCommand,
+    CreateClusterV2Command: client_kafka_1.CreateClusterV2Command,
+    CreateConfigurationCommand: client_kafka_1.CreateConfigurationCommand,
+    CreateReplicatorCommand: client_kafka_1.CreateReplicatorCommand,
+    CreateVpcConnectionCommand: client_kafka_1.CreateVpcConnectionCommand,
+    DeleteClusterCommand: client_kafka_1.DeleteClusterCommand,
+    DeleteClusterPolicyCommand: client_kafka_1.DeleteClusterPolicyCommand,
+    DeleteConfigurationCommand: client_kafka_1.DeleteConfigurationCommand,
+    DeleteReplicatorCommand: client_kafka_1.DeleteReplicatorCommand,
+    DeleteVpcConnectionCommand: client_kafka_1.DeleteVpcConnectionCommand,
+    DescribeClusterCommand: client_kafka_1.DescribeClusterCommand,
+    DescribeClusterOperationCommand: client_kafka_1.DescribeClusterOperationCommand,
+    DescribeClusterOperationV2Command: client_kafka_1.DescribeClusterOperationV2Command,
+    DescribeClusterV2Command: client_kafka_1.DescribeClusterV2Command,
+    DescribeConfigurationCommand: client_kafka_1.DescribeConfigurationCommand,
+    DescribeConfigurationRevisionCommand: client_kafka_1.DescribeConfigurationRevisionCommand,
+    DescribeReplicatorCommand: client_kafka_1.DescribeReplicatorCommand,
+    DescribeTopicCommand: client_kafka_1.DescribeTopicCommand,
+    DescribeTopicPartitionsCommand: client_kafka_1.DescribeTopicPartitionsCommand,
+    DescribeVpcConnectionCommand: client_kafka_1.DescribeVpcConnectionCommand,
+    GetBootstrapBrokersCommand: client_kafka_1.GetBootstrapBrokersCommand,
+    GetClusterPolicyCommand: client_kafka_1.GetClusterPolicyCommand,
+    GetCompatibleKafkaVersionsCommand: client_kafka_1.GetCompatibleKafkaVersionsCommand,
+    ListClientVpcConnectionsCommand: client_kafka_1.ListClientVpcConnectionsCommand,
+    ListClusterOperationsCommand: client_kafka_1.ListClusterOperationsCommand,
+    ListClusterOperationsV2Command: client_kafka_1.ListClusterOperationsV2Command,
+    ListClustersCommand: client_kafka_1.ListClustersCommand,
+    ListClustersV2Command: client_kafka_1.ListClustersV2Command,
+    ListConfigurationRevisionsCommand: client_kafka_1.ListConfigurationRevisionsCommand,
+    ListConfigurationsCommand: client_kafka_1.ListConfigurationsCommand,
+    ListKafkaVersionsCommand: client_kafka_1.ListKafkaVersionsCommand,
+    ListNodesCommand: client_kafka_1.ListNodesCommand,
+    ListReplicatorsCommand: client_kafka_1.ListReplicatorsCommand,
+    ListScramSecretsCommand: client_kafka_1.ListScramSecretsCommand,
+    ListTagsForResourceCommand: client_kafka_1.ListTagsForResourceCommand,
+    ListTopicsCommand: client_kafka_1.ListTopicsCommand,
+    ListVpcConnectionsCommand: client_kafka_1.ListVpcConnectionsCommand,
+    PutClusterPolicyCommand: client_kafka_1.PutClusterPolicyCommand,
+    RebootBrokerCommand: client_kafka_1.RebootBrokerCommand,
+    RejectClientVpcConnectionCommand: client_kafka_1.RejectClientVpcConnectionCommand,
+    TagResourceCommand: client_kafka_1.TagResourceCommand,
+    UntagResourceCommand: client_kafka_1.UntagResourceCommand,
+    UpdateBrokerCountCommand: client_kafka_1.UpdateBrokerCountCommand,
+    UpdateBrokerStorageCommand: client_kafka_1.UpdateBrokerStorageCommand,
+    UpdateBrokerTypeCommand: client_kafka_1.UpdateBrokerTypeCommand,
+    UpdateClusterConfigurationCommand: client_kafka_1.UpdateClusterConfigurationCommand,
+    UpdateClusterKafkaVersionCommand: client_kafka_1.UpdateClusterKafkaVersionCommand,
+    UpdateConfigurationCommand: client_kafka_1.UpdateConfigurationCommand,
+    UpdateConnectivityCommand: client_kafka_1.UpdateConnectivityCommand,
+    UpdateMonitoringCommand: client_kafka_1.UpdateMonitoringCommand,
+    UpdateRebalancingCommand: client_kafka_1.UpdateRebalancingCommand,
+    UpdateReplicationInfoCommand: client_kafka_1.UpdateReplicationInfoCommand,
+    UpdateSecurityCommand: client_kafka_1.UpdateSecurityCommand,
+    UpdateStorageCommand: client_kafka_1.UpdateStorageCommand,
+};
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+exports.makeKafkaService = effect_1.Effect.gen(function* () {
+    const client = yield* Instance.KafkaClientInstance;
+    return yield* commons_1.Service.fromClientAndCommands(client, commands, {
+        errorTags: Errors_js_1.AllServiceErrors,
+        resolveClientConfig: KafkaServiceConfig.toKafkaClientConfig,
+    });
+});
+/**
+ * @since 1.0.0
+ * @category models
+ */
+class KafkaService extends effect_1.Effect.Tag("@effect-aws/client-kafka/KafkaService")() {
+    static defaultLayer = effect_1.Layer.effect(this, exports.makeKafkaService).pipe(effect_1.Layer.provide(Instance.layer));
+    static layer = (config) => effect_1.Layer.effect(this, exports.makeKafkaService).pipe(effect_1.Layer.provide(Instance.layer), effect_1.Layer.provide(KafkaServiceConfig.setKafkaServiceConfig(config)));
+    static baseLayer = (evaluate) => effect_1.Layer.effect(this, exports.makeKafkaService).pipe(effect_1.Layer.provide(effect_1.Layer.effect(Instance.KafkaClientInstance, effect_1.Effect.map(KafkaServiceConfig.toKafkaClientConfig, evaluate))));
+}
+exports.KafkaService = KafkaService;
+//# sourceMappingURL=KafkaService.js.map

package/dist/cjs/KafkaService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KafkaService.js","sourceRoot":"","sources":["../../src/KafkaService.ts"],"names":[],"mappings":"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"}

package/dist/cjs/KafkaServiceConfig.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @since 1.0.0
+ */
+import type { KafkaClientConfig } from "@aws-sdk/client-kafka";
+import { Effect, Layer } from "effect";
+import type { KafkaService } from "./KafkaService.js";
+/**
+ * @since 1.0.0
+ * @category kafka service config
+ */
+export declare const withKafkaServiceConfig: {
+    (config: KafkaService.Config): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+    <A, E, R>(effect: Effect.Effect<A, E, R>, config: KafkaService.Config): Effect.Effect<A, E, R>;
+};
+/**
+ * @since 1.0.0
+ * @category kafka service config
+ */
+export declare const setKafkaServiceConfig: (config: KafkaService.Config) => Layer.Layer<never, never, never>;
+/**
+ * @since 1.0.0
+ * @category adapters
+ */
+export declare const toKafkaClientConfig: Effect.Effect<KafkaClientConfig>;
+//# sourceMappingURL=KafkaServiceConfig.d.ts.map

package/dist/cjs/KafkaServiceConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KafkaServiceConfig.d.ts","sourceRoot":"","sources":["../../src/KafkaServiceConfig.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAE,MAAM,EAAY,KAAK,EAAE,MAAM,QAAQ,CAAC;AAGjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAWtD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE;IACnC,CAAC,MAAM,EAAE,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACnG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKhG,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,WAAY,aAAa,MAAM,qCACT,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAQ/D,CAAC"}

package/dist/cjs/KafkaServiceConfig.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKafkaClientConfig = exports.setKafkaServiceConfig = exports.withKafkaServiceConfig = void 0;
+const commons_1 = require("@effect-aws/commons");
+const effect_1 = require("effect");
+const Function_1 = require("effect/Function");
+const GlobalValue_1 = require("effect/GlobalValue");
+/**
+ * @since 1.0.0
+ * @category kafka service config
+ */
+const currentKafkaServiceConfig = (0, GlobalValue_1.globalValue)("@effect-aws/client-kafka/currentKafkaServiceConfig", () => effect_1.FiberRef.unsafeMake({}));
+/**
+ * @since 1.0.0
+ * @category kafka service config
+ */
+exports.withKafkaServiceConfig = (0, Function_1.dual)(2, (effect, config) => effect_1.Effect.locally(effect, currentKafkaServiceConfig, config));
+/**
+ * @since 1.0.0
+ * @category kafka service config
+ */
+const setKafkaServiceConfig = (config) => effect_1.Layer.locallyScoped(currentKafkaServiceConfig, config);
+exports.setKafkaServiceConfig = setKafkaServiceConfig;
+/**
+ * @since 1.0.0
+ * @category adapters
+ */
+exports.toKafkaClientConfig = effect_1.Effect.gen(function* () {
+    const { logger: serviceLogger, ...config } = yield* effect_1.FiberRef.get(currentKafkaServiceConfig);
+    const logger = serviceLogger === true
+        ? yield* commons_1.ServiceLogger.toClientLogger(commons_1.ServiceLogger.defaultServiceLogger)
+        : (serviceLogger ? yield* commons_1.ServiceLogger.toClientLogger(commons_1.ServiceLogger.make(serviceLogger)) : undefined);
+    return { logger, ...config };
+});
+//# sourceMappingURL=KafkaServiceConfig.js.map

package/dist/cjs/KafkaServiceConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KafkaServiceConfig.js","sourceRoot":"","sources":["../../src/KafkaServiceConfig.ts"],"names":[],"mappings":";;;AAIA,iDAAoD;AACpD,mCAAiD;AACjD,8CAAuC;AACvC,oDAAiD;AAGjD;;;GAGG;AACH,MAAM,yBAAyB,GAAG,IAAA,yBAAW,EAC3C,oDAAoD,EACpD,GAAG,EAAE,CAAC,iBAAQ,CAAC,UAAU,CAAsB,EAAE,CAAC,CACnD,CAAC;AAEF;;;GAGG;AACU,QAAA,sBAAsB,GAG/B,IAAA,eAAI,EACN,CAAC,EACD,CAAU,MAA8B,EAAE,MAA2B,EAA0B,EAAE,CAC/F,eAAM,CAAC,OAAO,CAAC,MAAM,EAAE,yBAAyB,EAAE,MAAM,CAAC,CAC5D,CAAC;AAEF;;;GAGG;AACI,MAAM,qBAAqB,GAAG,CAAC,MAA2B,EAAE,EAAE,CACnE,cAAK,CAAC,aAAa,CAAC,yBAAyB,EAAE,MAAM,CAAC,CAAC;AAD5C,QAAA,qBAAqB,yBACuB;AAEzD;;;GAGG;AACU,QAAA,mBAAmB,GAAqC,eAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IACvF,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,iBAAQ,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;IAE5F,MAAM,MAAM,GAAG,aAAa,KAAK,IAAI;QACnC,CAAC,CAAC,KAAK,CAAC,CAAC,uBAAa,CAAC,cAAc,CAAC,uBAAa,CAAC,oBAAoB,CAAC;QACzE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,uBAAa,CAAC,cAAc,CAAC,uBAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAEzG,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AAC/B,CAAC,CAAC,CAAC"}

package/dist/cjs/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @since 1.0.0
+ */
+import { KafkaService } from "./KafkaService.js";
+/**
+ * @since 1.0.0
+ */
+export * from "./Errors.js";
+/**
+ * @since 1.0.0
+ */
+export * as KafkaClientInstance from "./KafkaClientInstance.js";
+/**
+ * @since 1.0.0
+ */
+export * as KafkaServiceConfig from "./KafkaServiceConfig.js";
+/**
+ * @since 1.0.0
+ */
+export * from "./KafkaService.js";
+/**
+ * @since 1.0.0
+ * @category exports
+ * @alias KafkaService
+ */
+export declare namespace Kafka {
+    /**
+     * @since 1.0.0
+     * @alias KafkaService.Config
+     */
+    type Config = KafkaService.Config;
+    /**
+     * @since 1.0.0
+     * @alias KafkaService.Type
+     */
+    type Type = KafkaService.Type;
+}
+/**
+ * @since 1.0.0
+ * @category exports
+ * @alias KafkaService
+ */
+export declare const Kafka: typeof KafkaService;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD;;GAEG;AACH,cAAc,aAAa,CAAC;AAE5B;;GAEG;AACH,OAAO,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAEhE;;GAEG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAC;AAE9D;;GAEG;AACH,cAAc,mBAAmB,CAAC;AAElC;;;;GAIG;AACH,MAAM,CAAC,OAAO,WAAW,KAAK,CAAC;IAC7B;;;OAGG;IACH,KAAY,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;IAEzC;;;OAGG;IACH,KAAY,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC;CACtC;AAED;;;;GAIG;AACH,eAAO,MAAM,KAAK,qBAAe,CAAC"}

package/dist/cjs/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Kafka = exports.KafkaServiceConfig = exports.KafkaClientInstance = void 0;
+/**
+ * @since 1.0.0
+ */
+const KafkaService_js_1 = require("./KafkaService.js");
+/**
+ * @since 1.0.0
+ */
+__exportStar(require("./Errors.js"), exports);
+/**
+ * @since 1.0.0
+ */
+exports.KafkaClientInstance = __importStar(require("./KafkaClientInstance.js"));
+/**
+ * @since 1.0.0
+ */
+exports.KafkaServiceConfig = __importStar(require("./KafkaServiceConfig.js"));
+/**
+ * @since 1.0.0
+ */
+__exportStar(require("./KafkaService.js"), exports);
+/**
+ * @since 1.0.0
+ * @category exports
+ * @alias KafkaService
+ */
+exports.Kafka = KafkaService_js_1.KafkaService;
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,uDAAiD;AAEjD;;GAEG;AACH,8CAA4B;AAE5B;;GAEG;AACH,gFAAgE;AAEhE;;GAEG;AACH,8EAA8D;AAE9D;;GAEG;AACH,oDAAkC;AAqBlC;;;;GAIG;AACU,QAAA,KAAK,GAAG,8BAAY,CAAC"}

package/dist/dts/Errors.d.ts

@@ -0,0 +1,15 @@
+import type { BadRequestException, ConflictException, ForbiddenException, InternalServerErrorException, NotFoundException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException } from "@aws-sdk/client-kafka";
+import type { TaggedException } from "@effect-aws/commons";
+export declare const AllServiceErrors: readonly ["BadRequestException", "ConflictException", "ForbiddenException", "InternalServerErrorException", "NotFoundException", "ServiceUnavailableException", "TooManyRequestsException", "UnauthorizedException"];
+export type BadRequestError = TaggedException<BadRequestException>;
+export type ConflictError = TaggedException<ConflictException>;
+export type ForbiddenError = TaggedException<ForbiddenException>;
+export type InternalServerError = TaggedException<InternalServerErrorException>;
+export type NotFoundError = TaggedException<NotFoundException>;
+export type ServiceUnavailableError = TaggedException<ServiceUnavailableException>;
+export type TooManyRequestsError = TaggedException<TooManyRequestsException>;
+export type UnauthorizedError = TaggedException<UnauthorizedException>;
+export type SdkError = TaggedException<Error & {
+    name: "SdkError";
+}>;
+//# sourceMappingURL=Errors.d.ts.map

package/dist/dts/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../src/Errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,4BAA4B,EAC5B,iBAAiB,EACjB,2BAA2B,EAC3B,wBAAwB,EACxB,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,eAAO,MAAM,gBAAgB,sNASnB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,eAAe,CAAC,mBAAmB,CAAC,CAAC;AACnE,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC,iBAAiB,CAAC,CAAC;AAC/D,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC,kBAAkB,CAAC,CAAC;AACjE,MAAM,MAAM,mBAAmB,GAAG,eAAe,CAAC,4BAA4B,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC,iBAAiB,CAAC,CAAC;AAC/D,MAAM,MAAM,uBAAuB,GAAG,eAAe,CAAC,2BAA2B,CAAC,CAAC;AACnF,MAAM,MAAM,oBAAoB,GAAG,eAAe,CAAC,wBAAwB,CAAC,CAAC;AAC7E,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC,qBAAqB,CAAC,CAAC;AACvE,MAAM,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,GAAG;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC"}

package/dist/dts/KafkaClientInstance.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @since 1.0.0
+ */
+import { KafkaClient } from "@aws-sdk/client-kafka";
+import { Context, Effect, Layer } from "effect";
+declare const KafkaClientInstance_base: Context.TagClass<KafkaClientInstance, "@effect-aws/client-kafka/KafkaClientInstance", KafkaClient>;
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export declare class KafkaClientInstance extends KafkaClientInstance_base {
+}
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: Effect.Effect<KafkaClient, never, import("effect/Scope").Scope>;
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layer: Layer.Layer<KafkaClientInstance, never, never>;
+export {};
+//# sourceMappingURL=KafkaClientInstance.d.ts.map

package/dist/dts/KafkaClientInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KafkaClientInstance.d.ts","sourceRoot":"","sources":["../../src/KafkaClientInstance.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;;AAGhD;;;GAGG;AACH,qBAAa,mBAAoB,SAAQ,wBAEJ;CAAG;AAExC;;;GAGG;AACH,eAAO,MAAM,IAAI,iEAOhB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,KAAK,gDAA0C,CAAC"}

package/dist/dts/KafkaService.d.ts

@@ -0,0 +1,270 @@
+/**
+ * @since 1.0.0
+ */
+import { type BatchAssociateScramSecretCommandInput, type BatchAssociateScramSecretCommandOutput, type BatchDisassociateScramSecretCommandInput, type BatchDisassociateScramSecretCommandOutput, type CreateClusterCommandInput, type CreateClusterCommandOutput, type CreateClusterV2CommandInput, type CreateClusterV2CommandOutput, type CreateConfigurationCommandInput, type CreateConfigurationCommandOutput, type CreateReplicatorCommandInput, type CreateReplicatorCommandOutput, type CreateVpcConnectionCommandInput, type CreateVpcConnectionCommandOutput, type DeleteClusterCommandInput, type DeleteClusterCommandOutput, type DeleteClusterPolicyCommandInput, type DeleteClusterPolicyCommandOutput, type DeleteConfigurationCommandInput, type DeleteConfigurationCommandOutput, type DeleteReplicatorCommandInput, type DeleteReplicatorCommandOutput, type DeleteVpcConnectionCommandInput, type DeleteVpcConnectionCommandOutput, type DescribeClusterCommandInput, type DescribeClusterCommandOutput, type DescribeClusterOperationCommandInput, type DescribeClusterOperationCommandOutput, type DescribeClusterOperationV2CommandInput, type DescribeClusterOperationV2CommandOutput, type DescribeClusterV2CommandInput, type DescribeClusterV2CommandOutput, type DescribeConfigurationCommandInput, type DescribeConfigurationCommandOutput, type DescribeConfigurationRevisionCommandInput, type DescribeConfigurationRevisionCommandOutput, type DescribeReplicatorCommandInput, type DescribeReplicatorCommandOutput, type DescribeTopicCommandInput, type DescribeTopicCommandOutput, type DescribeTopicPartitionsCommandInput, type DescribeTopicPartitionsCommandOutput, type DescribeVpcConnectionCommandInput, type DescribeVpcConnectionCommandOutput, type GetBootstrapBrokersCommandInput, type GetBootstrapBrokersCommandOutput, type GetClusterPolicyCommandInput, type GetClusterPolicyCommandOutput, type GetCompatibleKafkaVersionsCommandInput, type GetCompatibleKafkaVersionsCommandOutput, type KafkaClient, type KafkaClientConfig, type ListClientVpcConnectionsCommandInput, type ListClientVpcConnectionsCommandOutput, type ListClusterOperationsCommandInput, type ListClusterOperationsCommandOutput, type ListClusterOperationsV2CommandInput, type ListClusterOperationsV2CommandOutput, type ListClustersCommandInput, type ListClustersCommandOutput, type ListClustersV2CommandInput, type ListClustersV2CommandOutput, type ListConfigurationRevisionsCommandInput, type ListConfigurationRevisionsCommandOutput, type ListConfigurationsCommandInput, type ListConfigurationsCommandOutput, type ListKafkaVersionsCommandInput, type ListKafkaVersionsCommandOutput, type ListNodesCommandInput, type ListNodesCommandOutput, type ListReplicatorsCommandInput, type ListReplicatorsCommandOutput, type ListScramSecretsCommandInput, type ListScramSecretsCommandOutput, type ListTagsForResourceCommandInput, type ListTagsForResourceCommandOutput, type ListTopicsCommandInput, type ListTopicsCommandOutput, type ListVpcConnectionsCommandInput, type ListVpcConnectionsCommandOutput, type PutClusterPolicyCommandInput, type PutClusterPolicyCommandOutput, type RebootBrokerCommandInput, type RebootBrokerCommandOutput, type RejectClientVpcConnectionCommandInput, type RejectClientVpcConnectionCommandOutput, type TagResourceCommandInput, type TagResourceCommandOutput, type UntagResourceCommandInput, type UntagResourceCommandOutput, type UpdateBrokerCountCommandInput, type UpdateBrokerCountCommandOutput, type UpdateBrokerStorageCommandInput, type UpdateBrokerStorageCommandOutput, type UpdateBrokerTypeCommandInput, type UpdateBrokerTypeCommandOutput, type UpdateClusterConfigurationCommandInput, type UpdateClusterConfigurationCommandOutput, type UpdateClusterKafkaVersionCommandInput, type UpdateClusterKafkaVersionCommandOutput, type UpdateConfigurationCommandInput, type UpdateConfigurationCommandOutput, type UpdateConnectivityCommandInput, type UpdateConnectivityCommandOutput, type UpdateMonitoringCommandInput, type UpdateMonitoringCommandOutput, type UpdateRebalancingCommandInput, type UpdateRebalancingCommandOutput, type UpdateReplicationInfoCommandInput, type UpdateReplicationInfoCommandOutput, type UpdateSecurityCommandInput, type UpdateSecurityCommandOutput, type UpdateStorageCommandInput, type UpdateStorageCommandOutput } from "@aws-sdk/client-kafka";
+import type { HttpHandlerOptions, ServiceLogger } from "@effect-aws/commons";
+import type { Cause } from "effect";
+import { Effect, Layer } from "effect";
+import type { BadRequestError, ConflictError, ForbiddenError, InternalServerError, NotFoundError, SdkError, ServiceUnavailableError, TooManyRequestsError, UnauthorizedError } from "./Errors.js";
+import * as Instance from "./KafkaClientInstance.js";
+interface KafkaService$ {
+    readonly _: unique symbol;
+    /**
+     * @see {@link BatchAssociateScramSecretCommand}
+     */
+    batchAssociateScramSecret(args: BatchAssociateScramSecretCommandInput, options?: HttpHandlerOptions): Effect.Effect<BatchAssociateScramSecretCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link BatchDisassociateScramSecretCommand}
+     */
+    batchDisassociateScramSecret(args: BatchDisassociateScramSecretCommandInput, options?: HttpHandlerOptions): Effect.Effect<BatchDisassociateScramSecretCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link CreateClusterCommand}
+     */
+    createCluster(args: CreateClusterCommandInput, options?: HttpHandlerOptions): Effect.Effect<CreateClusterCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ConflictError | ForbiddenError | InternalServerError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link CreateClusterV2Command}
+     */
+    createClusterV2(args: CreateClusterV2CommandInput, options?: HttpHandlerOptions): Effect.Effect<CreateClusterV2CommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ConflictError | ForbiddenError | InternalServerError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link CreateConfigurationCommand}
+     */
+    createConfiguration(args: CreateConfigurationCommandInput, options?: HttpHandlerOptions): Effect.Effect<CreateConfigurationCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ConflictError | ForbiddenError | InternalServerError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link CreateReplicatorCommand}
+     */
+    createReplicator(args: CreateReplicatorCommandInput, options?: HttpHandlerOptions): Effect.Effect<CreateReplicatorCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ConflictError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link CreateVpcConnectionCommand}
+     */
+    createVpcConnection(args: CreateVpcConnectionCommandInput, options?: HttpHandlerOptions): Effect.Effect<CreateVpcConnectionCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link DeleteClusterCommand}
+     */
+    deleteCluster(args: DeleteClusterCommandInput, options?: HttpHandlerOptions): Effect.Effect<DeleteClusterCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link DeleteClusterPolicyCommand}
+     */
+    deleteClusterPolicy(args: DeleteClusterPolicyCommandInput, options?: HttpHandlerOptions): Effect.Effect<DeleteClusterPolicyCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link DeleteConfigurationCommand}
+     */
+    deleteConfiguration(args: DeleteConfigurationCommandInput, options?: HttpHandlerOptions): Effect.Effect<DeleteConfigurationCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link DeleteReplicatorCommand}
+     */
+    deleteReplicator(args: DeleteReplicatorCommandInput, options?: HttpHandlerOptions): Effect.Effect<DeleteReplicatorCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link DeleteVpcConnectionCommand}
+     */
+    deleteVpcConnection(args: DeleteVpcConnectionCommandInput, options?: HttpHandlerOptions): Effect.Effect<DeleteVpcConnectionCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link DescribeClusterCommand}
+     */
+    describeCluster(args: DescribeClusterCommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeClusterCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeClusterOperationCommand}
+     */
+    describeClusterOperation(args: DescribeClusterOperationCommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeClusterOperationCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeClusterOperationV2Command}
+     */
+    describeClusterOperationV2(args: DescribeClusterOperationV2CommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeClusterOperationV2CommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeClusterV2Command}
+     */
+    describeClusterV2(args: DescribeClusterV2CommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeClusterV2CommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeConfigurationCommand}
+     */
+    describeConfiguration(args: DescribeConfigurationCommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeConfigurationCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeConfigurationRevisionCommand}
+     */
+    describeConfigurationRevision(args: DescribeConfigurationRevisionCommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeConfigurationRevisionCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeReplicatorCommand}
+     */
+    describeReplicator(args: DescribeReplicatorCommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeReplicatorCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeTopicCommand}
+     */
+    describeTopic(args: DescribeTopicCommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeTopicCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeTopicPartitionsCommand}
+     */
+    describeTopicPartitions(args: DescribeTopicPartitionsCommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeTopicPartitionsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | UnauthorizedError>;
+    /**
+     * @see {@link DescribeVpcConnectionCommand}
+     */
+    describeVpcConnection(args: DescribeVpcConnectionCommandInput, options?: HttpHandlerOptions): Effect.Effect<DescribeVpcConnectionCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link GetBootstrapBrokersCommand}
+     */
+    getBootstrapBrokers(args: GetBootstrapBrokersCommandInput, options?: HttpHandlerOptions): Effect.Effect<GetBootstrapBrokersCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ConflictError | ForbiddenError | InternalServerError | UnauthorizedError>;
+    /**
+     * @see {@link GetClusterPolicyCommand}
+     */
+    getClusterPolicy(args: GetClusterPolicyCommandInput, options?: HttpHandlerOptions): Effect.Effect<GetClusterPolicyCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link GetCompatibleKafkaVersionsCommand}
+     */
+    getCompatibleKafkaVersions(args: GetCompatibleKafkaVersionsCommandInput, options?: HttpHandlerOptions): Effect.Effect<GetCompatibleKafkaVersionsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link ListClientVpcConnectionsCommand}
+     */
+    listClientVpcConnections(args: ListClientVpcConnectionsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListClientVpcConnectionsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link ListClusterOperationsCommand}
+     */
+    listClusterOperations(args: ListClusterOperationsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListClusterOperationsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | UnauthorizedError>;
+    /**
+     * @see {@link ListClusterOperationsV2Command}
+     */
+    listClusterOperationsV2(args: ListClusterOperationsV2CommandInput, options?: HttpHandlerOptions): Effect.Effect<ListClusterOperationsV2CommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link ListClustersCommand}
+     */
+    listClusters(args: ListClustersCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListClustersCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | UnauthorizedError>;
+    /**
+     * @see {@link ListClustersV2Command}
+     */
+    listClustersV2(args: ListClustersV2CommandInput, options?: HttpHandlerOptions): Effect.Effect<ListClustersV2CommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | UnauthorizedError>;
+    /**
+     * @see {@link ListConfigurationRevisionsCommand}
+     */
+    listConfigurationRevisions(args: ListConfigurationRevisionsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListConfigurationRevisionsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link ListConfigurationsCommand}
+     */
+    listConfigurations(args: ListConfigurationsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListConfigurationsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link ListKafkaVersionsCommand}
+     */
+    listKafkaVersions(args: ListKafkaVersionsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListKafkaVersionsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | UnauthorizedError>;
+    /**
+     * @see {@link ListNodesCommand}
+     */
+    listNodes(args: ListNodesCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListNodesCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link ListReplicatorsCommand}
+     */
+    listReplicators(args: ListReplicatorsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListReplicatorsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link ListScramSecretsCommand}
+     */
+    listScramSecrets(args: ListScramSecretsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListScramSecretsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link ListTagsForResourceCommand}
+     */
+    listTagsForResource(args: ListTagsForResourceCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListTagsForResourceCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link ListTopicsCommand}
+     */
+    listTopics(args: ListTopicsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListTopicsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link ListVpcConnectionsCommand}
+     */
+    listVpcConnections(args: ListVpcConnectionsCommandInput, options?: HttpHandlerOptions): Effect.Effect<ListVpcConnectionsCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link PutClusterPolicyCommand}
+     */
+    putClusterPolicy(args: PutClusterPolicyCommandInput, options?: HttpHandlerOptions): Effect.Effect<PutClusterPolicyCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError>;
+    /**
+     * @see {@link RebootBrokerCommand}
+     */
+    rebootBroker(args: RebootBrokerCommandInput, options?: HttpHandlerOptions): Effect.Effect<RebootBrokerCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link RejectClientVpcConnectionCommand}
+     */
+    rejectClientVpcConnection(args: RejectClientVpcConnectionCommandInput, options?: HttpHandlerOptions): Effect.Effect<RejectClientVpcConnectionCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link TagResourceCommand}
+     */
+    tagResource(args: TagResourceCommandInput, options?: HttpHandlerOptions): Effect.Effect<TagResourceCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link UntagResourceCommand}
+     */
+    untagResource(args: UntagResourceCommandInput, options?: HttpHandlerOptions): Effect.Effect<UntagResourceCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | InternalServerError | NotFoundError>;
+    /**
+     * @see {@link UpdateBrokerCountCommand}
+     */
+    updateBrokerCount(args: UpdateBrokerCountCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateBrokerCountCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateBrokerStorageCommand}
+     */
+    updateBrokerStorage(args: UpdateBrokerStorageCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateBrokerStorageCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateBrokerTypeCommand}
+     */
+    updateBrokerType(args: UpdateBrokerTypeCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateBrokerTypeCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateClusterConfigurationCommand}
+     */
+    updateClusterConfiguration(args: UpdateClusterConfigurationCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateClusterConfigurationCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateClusterKafkaVersionCommand}
+     */
+    updateClusterKafkaVersion(args: UpdateClusterKafkaVersionCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateClusterKafkaVersionCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateConfigurationCommand}
+     */
+    updateConfiguration(args: UpdateConfigurationCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateConfigurationCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateConnectivityCommand}
+     */
+    updateConnectivity(args: UpdateConnectivityCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateConnectivityCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateMonitoringCommand}
+     */
+    updateMonitoring(args: UpdateMonitoringCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateMonitoringCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | ServiceUnavailableError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateRebalancingCommand}
+     */
+    updateRebalancing(args: UpdateRebalancingCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateRebalancingCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateReplicationInfoCommand}
+     */
+    updateReplicationInfo(args: UpdateReplicationInfoCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateReplicationInfoCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateSecurityCommand}
+     */
+    updateSecurity(args: UpdateSecurityCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateSecurityCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+    /**
+     * @see {@link UpdateStorageCommand}
+     */
+    updateStorage(args: UpdateStorageCommandInput, options?: HttpHandlerOptions): Effect.Effect<UpdateStorageCommandOutput, Cause.TimeoutException | SdkError | BadRequestError | ForbiddenError | InternalServerError | NotFoundError | ServiceUnavailableError | TooManyRequestsError | UnauthorizedError>;
+}
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const makeKafkaService: Effect.Effect<KafkaService$, never, Instance.KafkaClientInstance>;
+declare const KafkaService_base: import("effect/Context").TagClass<KafkaService, "@effect-aws/client-kafka/KafkaService", KafkaService$> & Effect.Tag.Proxy<KafkaService, KafkaService$> & {
+    use: <X>(body: (_: KafkaService$) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, KafkaService | R> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, Cause.UnknownException, KafkaService> : Effect.Effect<X, never, KafkaService>;
+};
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare class KafkaService extends KafkaService_base {
+    static readonly defaultLayer: Layer.Layer<KafkaService, never, never>;
+    static readonly layer: (config: KafkaService.Config) => Layer.Layer<KafkaService, never, never>;
+    static readonly baseLayer: (evaluate: (defaultConfig: KafkaClientConfig) => KafkaClient) => Layer.Layer<KafkaService, never, never>;
+}
+/**
+ * @since 1.0.0
+ */
+export declare namespace KafkaService {
+    /**
+     * @since 1.0.0
+     */
+    interface Config extends Omit<KafkaClientConfig, "logger"> {
+        readonly logger?: ServiceLogger.ServiceLoggerConstructorProps | true;
+    }
+    /**
+     * @since 1.0.0
+     */
+    type Type = KafkaService$;
+}
+export {};
+//# sourceMappingURL=KafkaService.d.ts.map