@wildix/wim-cache-client 1.0.0

package/dist-types/commands/SearchEntitiesByParamsCommand.d.ts

@@ -0,0 +1,120 @@
+import { ServiceInputTypes, ServiceOutputTypes, WimCacheClientResolvedConfig } from "../WimCacheClient";
+import { SearchEntitiesByParamsInput, SearchEntitiesByParamsOutput } from "../models/models_0";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@smithy/types";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link SearchEntitiesByParamsCommand}.
+ */
+export interface SearchEntitiesByParamsCommandInput extends SearchEntitiesByParamsInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link SearchEntitiesByParamsCommand}.
+ */
+export interface SearchEntitiesByParamsCommandOutput extends SearchEntitiesByParamsOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * Searches for entities, unlike a POST request allows to specify additional parameters such as 'query', 'from', and 'size'. requires one of the parameters: query or email or phone
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WimCacheClient, SearchEntitiesByParamsCommand } from "@wildix/wim-cache-client"; // ES Modules import
+ * // const { WimCacheClient, SearchEntitiesByParamsCommand } = require("@wildix/wim-cache-client"); // CommonJS import
+ * const client = new WimCacheClient(config);
+ * const input = { // SearchEntitiesByParamsInput
+ *   organizationId: "STRING_VALUE",
+ *   phone: "STRING_VALUE",
+ *   email: "STRING_VALUE",
+ *   query: "STRING_VALUE",
+ *   from: Number("int"),
+ *   size: Number("int"),
+ * };
+ * const command = new SearchEntitiesByParamsCommand(input);
+ * const response = await client.send(command);
+ * // { // SearchEntitiesByParamsOutput
+ * //   items: [ // SearchResultList
+ * //     { // SearchResult
+ * //       email: "STRING_VALUE",
+ * //       phone: "STRING_VALUE",
+ * //       items: [ // EntityList
+ * //         { // Entity
+ * //           integrationId: "STRING_VALUE", // required
+ * //           entityType: "STRING_VALUE", // required
+ * //           data: { // EntityData
+ * //             Id: "STRING_VALUE",
+ * //             Name: "STRING_VALUE",
+ * //             FirstName: "STRING_VALUE",
+ * //             LastName: "STRING_VALUE",
+ * //             Phone: "STRING_VALUE",
+ * //             Email: "STRING_VALUE",
+ * //             OwnerId: "STRING_VALUE",
+ * //             MobilePhone: "STRING_VALUE",
+ * //             AccountId: "STRING_VALUE",
+ * //             Company: "STRING_VALUE",
+ * //             IsConverted: true || false,
+ * //             LastModifiedDate: "STRING_VALUE",
+ * //             CompanyName: "STRING_VALUE",
+ * //             IsActive: true || false,
+ * //             TimeZoneSidKey: "STRING_VALUE",
+ * //             Extension: "STRING_VALUE",
+ * //             attributes: { // SalesforceAttrubuteField
+ * //               url: "STRING_VALUE",
+ * //               type: "STRING_VALUE",
+ * //             },
+ * //             CallPhone: "STRING_VALUE",
+ * //             Archived: true || false,
+ * //             Domain: "STRING_VALUE",
+ * //             UpdatedAt: "STRING_VALUE",
+ * //             Avatar: "STRING_VALUE",
+ * //             CustomData: { // GeneralDataMap
+ * //               "<keys>": "STRING_VALUE",
+ * //             },
+ * //           },
+ * //           integrationOrder: Number("int"),
+ * //         },
+ * //       ],
+ * //     },
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param SearchEntitiesByParamsCommandInput - {@link SearchEntitiesByParamsCommandInput}
+ * @returns {@link SearchEntitiesByParamsCommandOutput}
+ * @see {@link SearchEntitiesByParamsCommandInput} for command's `input` shape.
+ * @see {@link SearchEntitiesByParamsCommandOutput} for command's `response` shape.
+ * @see {@link WimCacheClientResolvedConfig | config} for WimCacheClient's `config` shape.
+ *
+ * @throws {@link ValidationException} (client fault)
+ *
+ * @throws {@link WimCacheServiceException}
+ * <p>Base exception class for all service exceptions from WimCache service.</p>
+ *
+ */
+export declare class SearchEntitiesByParamsCommand extends $Command<SearchEntitiesByParamsCommandInput, SearchEntitiesByParamsCommandOutput, WimCacheClientResolvedConfig> {
+    readonly input: SearchEntitiesByParamsCommandInput;
+    /**
+     * @public
+     */
+    constructor(input: SearchEntitiesByParamsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WimCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchEntitiesByParamsCommandInput, SearchEntitiesByParamsCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/SyncCacheCommand.d.ts

@@ -0,0 +1,73 @@
+import { ServiceInputTypes, ServiceOutputTypes, WimCacheClientResolvedConfig } from "../WimCacheClient";
+import { SyncCacheInput, SyncCacheOutput } from "../models/models_0";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@smithy/types";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link SyncCacheCommand}.
+ */
+export interface SyncCacheCommandInput extends SyncCacheInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link SyncCacheCommand}.
+ */
+export interface SyncCacheCommandOutput extends SyncCacheOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * Allows to run target integration synchronization
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WimCacheClient, SyncCacheCommand } from "@wildix/wim-cache-client"; // ES Modules import
+ * // const { WimCacheClient, SyncCacheCommand } = require("@wildix/wim-cache-client"); // CommonJS import
+ * const client = new WimCacheClient(config);
+ * const input = { // SyncCacheInput
+ *   organizationId: "STRING_VALUE", // required
+ * };
+ * const command = new SyncCacheCommand(input);
+ * const response = await client.send(command);
+ * // { // SyncCacheOutput
+ * //   success: true || false,
+ * // };
+ *
+ * ```
+ *
+ * @param SyncCacheCommandInput - {@link SyncCacheCommandInput}
+ * @returns {@link SyncCacheCommandOutput}
+ * @see {@link SyncCacheCommandInput} for command's `input` shape.
+ * @see {@link SyncCacheCommandOutput} for command's `response` shape.
+ * @see {@link WimCacheClientResolvedConfig | config} for WimCacheClient's `config` shape.
+ *
+ * @throws {@link ValidationException} (client fault)
+ *
+ * @throws {@link WimCacheServiceException}
+ * <p>Base exception class for all service exceptions from WimCache service.</p>
+ *
+ */
+export declare class SyncCacheCommand extends $Command<SyncCacheCommandInput, SyncCacheCommandOutput, WimCacheClientResolvedConfig> {
+    readonly input: SyncCacheCommandInput;
+    /**
+     * @public
+     */
+    constructor(input: SyncCacheCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WimCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SyncCacheCommandInput, SyncCacheCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./DeleteEntitiesFromGeneralCacheCommand";
+export * from "./GetEntitiesByIdsCommand";
+export * from "./PutEntitiesToGeneralCacheCommand";
+export * from "./SearchEntitiesByListParamsCommand";
+export * from "./SearchEntitiesByParamsCommand";
+export * from "./SyncCacheCommand";

package/dist-types/extensionConfiguration.d.ts

@@ -0,0 +1,7 @@
+import { HttpHandlerExtensionConfiguration } from "@smithy/protocol-http";
+import { DefaultExtensionConfiguration } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface WimCacheExtensionConfiguration extends HttpHandlerExtensionConfiguration, DefaultExtensionConfiguration {
+}

package/dist-types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./WimCacheClient";
+export * from "./WimCache";
+export * from "./commands";
+export * from "./models";
+export { WimCacheServiceException } from "./models/WimCacheServiceException";

package/dist-types/models/WimCacheServiceException.d.ts

@@ -0,0 +1,13 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@smithy/smithy-client";
+export { __ServiceException, __ServiceExceptionOptions };
+/**
+ * @public
+ *
+ * Base exception class for all service exceptions from WimCache service.
+ */
+export declare class WimCacheServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-types/models/models_0.d.ts

@@ -0,0 +1,230 @@
+import { WimCacheServiceException as __BaseException } from "./WimCacheServiceException";
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+/**
+ * @public
+ */
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+/**
+ * @public
+ */
+export interface DeleteEntitiesFromGeneralCacheInput {
+    /**
+     * @public
+     * Email for delete
+     */
+    email?: string;
+    /**
+     * @public
+     * Phone for delete
+     */
+    phone?: string;
+    /**
+     * @public
+     * Delete all general cache for the current user
+     */
+    clean?: boolean;
+}
+/**
+ * @public
+ */
+export interface DeleteEntitiesFromGeneralCacheOutput {
+}
+/**
+ * @public
+ */
+export interface SalesforceAttrubuteField {
+    url?: string;
+    type?: string;
+}
+/**
+ * @public
+ */
+export interface EntityData {
+    Id?: string;
+    Name?: string;
+    FirstName?: string;
+    LastName?: string;
+    Phone?: string;
+    Email?: string;
+    OwnerId?: string;
+    MobilePhone?: string;
+    AccountId?: string;
+    Company?: string;
+    IsConverted?: boolean;
+    LastModifiedDate?: string;
+    CompanyName?: string;
+    IsActive?: boolean;
+    TimeZoneSidKey?: string;
+    Extension?: string;
+    attributes?: SalesforceAttrubuteField;
+    CallPhone?: string;
+    Archived?: boolean;
+    Domain?: string;
+    UpdatedAt?: string;
+    Avatar?: string;
+    CustomData?: Record<string, string>;
+}
+/**
+ * @public
+ */
+export interface Entity {
+    integrationId: string;
+    entityType: string;
+    data: EntityData;
+    integrationOrder?: number;
+}
+/**
+ * @public
+ */
+export interface GeneralEntityInputData {
+    IntegrationId: string;
+    IntegrationOrder: number;
+    Name?: string;
+    Id?: string;
+    Phone?: string;
+    Email?: string;
+    OwnerId?: string;
+    Avatar?: string;
+    UpdatedAt?: string;
+    CustomData?: Record<string, string>;
+}
+/**
+ * @public
+ */
+export interface GetEntitiesByIdsInput {
+    /**
+     * @public
+     * Organization identifier
+     */
+    organizationId?: string;
+    /**
+     * @public
+     * Unique Entities identifiers
+     */
+    entityIds: (string)[];
+}
+/**
+ * @public
+ */
+export interface GetEntitiesByIdsOutput {
+    items?: (Entity)[];
+}
+/**
+ * @public
+ */
+export interface PutEntitiesToGeneralCacheInput {
+    items?: (GeneralEntityInputData)[];
+}
+/**
+ * @public
+ */
+export interface PutEntitiesToGeneralCacheOutput {
+}
+/**
+ * @public
+ */
+export interface SearchPostParams {
+    /**
+     * @public
+     * Phone for search
+     */
+    phone?: string;
+    /**
+     * @public
+     * Email for search
+     */
+    email?: string;
+}
+/**
+ * @public
+ */
+export interface SearchEntitiesByListParamsInput {
+    /**
+     * @public
+     * Organization identifier
+     */
+    organizationId?: string;
+    /**
+     * @public
+     * Params for search
+     */
+    params: (SearchPostParams)[];
+}
+/**
+ * @public
+ */
+export interface SearchResult {
+    email?: string;
+    phone?: string;
+    items?: (Entity)[];
+}
+/**
+ * @public
+ */
+export interface SearchEntitiesByListParamsOutput {
+    items?: (SearchResult)[];
+}
+/**
+ * @public
+ */
+export interface SearchEntitiesByParamsInput {
+    /**
+     * @public
+     * Unique organization identifier
+     */
+    organizationId?: string;
+    /**
+     * @public
+     * Phone for search
+     */
+    phone?: string;
+    /**
+     * @public
+     * Email for search
+     */
+    email?: string;
+    /**
+     * @public
+     * Query string for search (use only for Backend auto loging integrations)
+     */
+    query?: string;
+    /**
+     * @public
+     * Starting document offset. Needs to by non-negative and defaults to 0
+     */
+    from?: number;
+    /**
+     * @public
+     * Defines the number of hits to return. Defaults to 10
+     */
+    size?: number;
+}
+/**
+ * @public
+ */
+export interface SearchEntitiesByParamsOutput {
+    items?: (SearchResult)[];
+}
+/**
+ * @public
+ */
+export interface SyncCacheInput {
+    /**
+     * @public
+     * Organization identifier
+     */
+    organizationId: string;
+}
+/**
+ * @public
+ */
+export interface SyncCacheOutput {
+    success?: boolean;
+}

package/dist-types/protocols/Aws_restJson1.d.ts

@@ -0,0 +1,56 @@
+import { DeleteEntitiesFromGeneralCacheCommandInput, DeleteEntitiesFromGeneralCacheCommandOutput } from "../commands/DeleteEntitiesFromGeneralCacheCommand";
+import { GetEntitiesByIdsCommandInput, GetEntitiesByIdsCommandOutput } from "../commands/GetEntitiesByIdsCommand";
+import { PutEntitiesToGeneralCacheCommandInput, PutEntitiesToGeneralCacheCommandOutput } from "../commands/PutEntitiesToGeneralCacheCommand";
+import { SearchEntitiesByListParamsCommandInput, SearchEntitiesByListParamsCommandOutput } from "../commands/SearchEntitiesByListParamsCommand";
+import { SearchEntitiesByParamsCommandInput, SearchEntitiesByParamsCommandOutput } from "../commands/SearchEntitiesByParamsCommand";
+import { SyncCacheCommandInput, SyncCacheCommandOutput } from "../commands/SyncCacheCommand";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+import { SerdeContext as __SerdeContext } from "@smithy/types";
+/**
+ * serializeAws_restJson1DeleteEntitiesFromGeneralCacheCommand
+ */
+export declare const se_DeleteEntitiesFromGeneralCacheCommand: (input: DeleteEntitiesFromGeneralCacheCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+/**
+ * serializeAws_restJson1GetEntitiesByIdsCommand
+ */
+export declare const se_GetEntitiesByIdsCommand: (input: GetEntitiesByIdsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+/**
+ * serializeAws_restJson1PutEntitiesToGeneralCacheCommand
+ */
+export declare const se_PutEntitiesToGeneralCacheCommand: (input: PutEntitiesToGeneralCacheCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+/**
+ * serializeAws_restJson1SearchEntitiesByListParamsCommand
+ */
+export declare const se_SearchEntitiesByListParamsCommand: (input: SearchEntitiesByListParamsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+/**
+ * serializeAws_restJson1SearchEntitiesByParamsCommand
+ */
+export declare const se_SearchEntitiesByParamsCommand: (input: SearchEntitiesByParamsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+/**
+ * serializeAws_restJson1SyncCacheCommand
+ */
+export declare const se_SyncCacheCommand: (input: SyncCacheCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+/**
+ * deserializeAws_restJson1DeleteEntitiesFromGeneralCacheCommand
+ */
+export declare const de_DeleteEntitiesFromGeneralCacheCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DeleteEntitiesFromGeneralCacheCommandOutput>;
+/**
+ * deserializeAws_restJson1GetEntitiesByIdsCommand
+ */
+export declare const de_GetEntitiesByIdsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetEntitiesByIdsCommandOutput>;
+/**
+ * deserializeAws_restJson1PutEntitiesToGeneralCacheCommand
+ */
+export declare const de_PutEntitiesToGeneralCacheCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<PutEntitiesToGeneralCacheCommandOutput>;
+/**
+ * deserializeAws_restJson1SearchEntitiesByListParamsCommand
+ */
+export declare const de_SearchEntitiesByListParamsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SearchEntitiesByListParamsCommandOutput>;
+/**
+ * deserializeAws_restJson1SearchEntitiesByParamsCommand
+ */
+export declare const de_SearchEntitiesByParamsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SearchEntitiesByParamsCommandOutput>;
+/**
+ * deserializeAws_restJson1SyncCacheCommand
+ */
+export declare const de_SyncCacheCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SyncCacheCommandOutput>;

package/dist-types/runtimeConfig.browser.d.ts

@@ -0,0 +1,27 @@
+import { FetchHttpHandler as RequestHandler } from "@smithy/fetch-http-handler";
+import { WimCacheClientConfig } from "./WimCacheClient";
+/**
+ * @internal
+ */
+export declare const getRuntimeConfig: (config: WimCacheClientConfig) => {
+    runtime: string;
+    defaultsMode: import("@smithy/types").Provider<import("@smithy/smithy-client").ResolvedDefaultsMode>;
+    bodyLengthChecker: import("@smithy/types").BodyLengthCalculator;
+    maxAttempts: number | import("@smithy/types").Provider<number>;
+    requestHandler: ((import("@smithy/types").RequestHandler<any, any, import("@smithy/types").HttpHandlerOptions> | Record<string, unknown> | import("@smithy/types").NodeHttpHandlerOptions | import("@smithy/fetch-http-handler").FetchHttpHandlerOptions) & import("@smithy/types").RequestHandler<import("@smithy/protocol-http").HttpRequest, import("@smithy/protocol-http").HttpResponse, import("@smithy/types").HttpHandlerOptions> & {
+        updateHttpClientConfig(key: never, value: never): void;
+        httpHandlerConfigs(): {};
+    }) | RequestHandler;
+    retryMode: string | import("@smithy/types").Provider<string>;
+    sha256: import("@smithy/types").HashConstructor;
+    streamCollector: import("@smithy/types").StreamCollector;
+    apiVersion: string;
+    urlParser: import("@smithy/types").UrlParser;
+    base64Decoder: import("@smithy/types").Decoder;
+    base64Encoder: (_input: string | Uint8Array) => string;
+    utf8Decoder: import("@smithy/types").Decoder;
+    utf8Encoder: (input: string | Uint8Array) => string;
+    disableHostPrefix: boolean;
+    logger: import("@smithy/types").Logger;
+    extensions: import("./runtimeExtensions").RuntimeExtension[];
+};

package/dist-types/runtimeConfig.d.ts

@@ -0,0 +1,27 @@
+import { NodeHttpHandler as RequestHandler } from "@smithy/node-http-handler";
+import { WimCacheClientConfig } from "./WimCacheClient";
+/**
+ * @internal
+ */
+export declare const getRuntimeConfig: (config: WimCacheClientConfig) => {
+    runtime: string;
+    defaultsMode: import("@smithy/types").Provider<import("@smithy/smithy-client").ResolvedDefaultsMode>;
+    bodyLengthChecker: import("@smithy/types").BodyLengthCalculator;
+    maxAttempts: number | import("@smithy/types").Provider<number>;
+    requestHandler: ((import("@smithy/types").RequestHandler<any, any, import("@smithy/types").HttpHandlerOptions> | Record<string, unknown> | import("@smithy/node-http-handler").NodeHttpHandlerOptions | import("@smithy/types").FetchHttpHandlerOptions) & import("@smithy/types").RequestHandler<import("@smithy/protocol-http").HttpRequest, import("@smithy/protocol-http").HttpResponse, import("@smithy/types").HttpHandlerOptions> & {
+        updateHttpClientConfig(key: never, value: never): void;
+        httpHandlerConfigs(): {};
+    }) | RequestHandler;
+    retryMode: string | import("@smithy/types").Provider<string>;
+    sha256: import("@smithy/types").HashConstructor;
+    streamCollector: import("@smithy/types").StreamCollector;
+    apiVersion: string;
+    urlParser: import("@smithy/types").UrlParser;
+    base64Decoder: import("@smithy/types").Decoder;
+    base64Encoder: (_input: string | Uint8Array) => string;
+    utf8Decoder: import("@smithy/types").Decoder;
+    utf8Encoder: (input: string | Uint8Array) => string;
+    disableHostPrefix: boolean;
+    logger: import("@smithy/types").Logger;
+    extensions: import("./runtimeExtensions").RuntimeExtension[];
+};

package/dist-types/runtimeConfig.native.d.ts

@@ -0,0 +1,26 @@
+import { WimCacheClientConfig } from "./WimCacheClient";
+/**
+ * @internal
+ */
+export declare const getRuntimeConfig: (config: WimCacheClientConfig) => {
+    runtime: string;
+    sha256: import("@smithy/types").HashConstructor;
+    requestHandler: ((import("@smithy/types").RequestHandler<any, any, import("@smithy/types").HttpHandlerOptions> | Record<string, unknown> | import("@smithy/types").NodeHttpHandlerOptions | import("@smithy/types").FetchHttpHandlerOptions) & import("@smithy/types").RequestHandler<import("@smithy/protocol-http").HttpRequest, import("@smithy/protocol-http").HttpResponse, import("@smithy/types").HttpHandlerOptions> & {
+        updateHttpClientConfig(key: never, value: never): void;
+        httpHandlerConfigs(): {};
+    }) | import("@smithy/fetch-http-handler").FetchHttpHandler;
+    apiVersion: string;
+    urlParser: import("@smithy/types").UrlParser;
+    bodyLengthChecker: import("@smithy/types").BodyLengthCalculator;
+    streamCollector: import("@smithy/types").StreamCollector;
+    base64Decoder: import("@smithy/types").Decoder;
+    base64Encoder: (_input: string | Uint8Array) => string;
+    utf8Decoder: import("@smithy/types").Decoder;
+    utf8Encoder: (input: string | Uint8Array) => string;
+    disableHostPrefix: boolean;
+    maxAttempts: number | import("@smithy/types").Provider<number>;
+    retryMode: string | import("@smithy/types").Provider<string>;
+    logger: import("@smithy/types").Logger;
+    extensions: import("./runtimeExtensions").RuntimeExtension[];
+    defaultsMode: import("@smithy/smithy-client").DefaultsMode | import("@smithy/types").Provider<import("@smithy/smithy-client").DefaultsMode>;
+};

package/dist-types/runtimeConfig.shared.d.ts

@@ -0,0 +1,15 @@
+import { WimCacheClientConfig } from "./WimCacheClient";
+/**
+ * @internal
+ */
+export declare const getRuntimeConfig: (config: WimCacheClientConfig) => {
+    apiVersion: string;
+    base64Decoder: import("@smithy/types").Decoder;
+    base64Encoder: (_input: string | Uint8Array) => string;
+    disableHostPrefix: boolean;
+    extensions: import("./runtimeExtensions").RuntimeExtension[];
+    logger: import("@smithy/types").Logger;
+    urlParser: import("@smithy/types").UrlParser;
+    utf8Decoder: import("@smithy/types").Decoder;
+    utf8Encoder: (input: string | Uint8Array) => string;
+};

package/dist-types/runtimeExtensions.d.ts

@@ -0,0 +1,17 @@
+import { WimCacheExtensionConfiguration } from "./extensionConfiguration";
+/**
+ * @public
+ */
+export interface RuntimeExtension {
+    configure(extensionConfiguration: WimCacheExtensionConfiguration): void;
+}
+/**
+ * @public
+ */
+export interface RuntimeExtensionsConfig {
+    extensions: RuntimeExtension[];
+}
+/**
+ * @internal
+ */
+export declare const resolveRuntimeExtensions: (runtimeConfig: any, extensions: RuntimeExtension[]) => any;