@kong-ui-public/entities-redis-configurations 0.0.1

package/dist/types/components/RedisConfigurationForm.vue.d.ts

@@ -0,0 +1,87 @@
+import '@kong-ui-public/entities-shared/dist/style.css';
+import '@kong-ui-public/entities-vaults/dist/style.css';
+import { PartialType } from '../types';
+import type { PropType } from 'vue';
+import type { KongManagerRedisConfigurationFormConfig, KonnectRedisConfigurationFormConfig, RedisConfigurationResponse } from '../types';
+import type { AxiosError } from 'axios';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<KonnectRedisConfigurationFormConfig | KongManagerRedisConfigurationFormConfig>;
+        required: true;
+        validator: (config: KonnectRedisConfigurationFormConfig | KongManagerRedisConfigurationFormConfig) => boolean;
+    };
+    /** If a valid partialId is provided, it will put the form in Edit mode instead of Create */
+    partialId: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Teleport target for the actions
+     */
+    actionTeleportTarget: {
+        type: StringConstructor;
+    };
+    /**
+     * Top offset for the slideout
+     */
+    slidoutTopOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * Set disabled partial type, only for create mode
+     */
+    disabledPartialType: {
+        type: PropType<PartialType>;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    cancel: () => any;
+    error: (error: AxiosError<unknown, any>) => any;
+    loading: (isLoading: boolean) => any;
+    update: (data: RedisConfigurationResponse) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<KonnectRedisConfigurationFormConfig | KongManagerRedisConfigurationFormConfig>;
+        required: true;
+        validator: (config: KonnectRedisConfigurationFormConfig | KongManagerRedisConfigurationFormConfig) => boolean;
+    };
+    /** If a valid partialId is provided, it will put the form in Edit mode instead of Create */
+    partialId: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    /**
+     * Teleport target for the actions
+     */
+    actionTeleportTarget: {
+        type: StringConstructor;
+    };
+    /**
+     * Top offset for the slideout
+     */
+    slidoutTopOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * Set disabled partial type, only for create mode
+     */
+    disabledPartialType: {
+        type: PropType<PartialType>;
+        default: string;
+    };
+}>> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onError?: ((error: AxiosError<unknown, any>) => any) | undefined;
+    onLoading?: ((isLoading: boolean) => any) | undefined;
+    onUpdate?: ((data: RedisConfigurationResponse) => any) | undefined;
+}>, {
+    partialId: string;
+    slidoutTopOffset: number;
+    disabledPartialType: PartialType;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=RedisConfigurationForm.vue.d.ts.map

package/dist/types/components/RedisConfigurationForm.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisConfigurationForm.vue.d.ts","sourceRoot":"","sources":["../../../src/components/RedisConfigurationForm.vue"],"names":[],"mappings":"AA2nBA,OAAO,gDAAgD,CAAA;AACvD,OAAO,gDAAgD,CAAA;AAMvD,OAAO,EAAa,WAAW,EAAE,MAAM,UAAU,CAAA;AAOjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,KAAK,EACV,uCAAuC,EACvC,mCAAmC,EACnC,0BAA0B,EAC3B,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;;;cAs7BnB,QAAQ,CAAC,mCAAmC,GAAG,uCAAuC,CAAC;;4BAEnF,mCAAmC,GAAG,uCAAuC;;IAOnG,4FAA4F;;;;;;IAM5F;;OAEG;;;;IAIH;;OAEG;;;;;IAKH;;OAEG;;cAEe,QAAQ,CAAC,WAAW,CAAC;;;;;;;;;;cAhCrB,QAAQ,CAAC,mCAAmC,GAAG,uCAAuC,CAAC;;4BAEnF,mCAAmC,GAAG,uCAAuC;;IAOnG,4FAA4F;;;;;;IAM5F;;OAEG;;;;IAIH;;OAEG;;;;;IAKH;;OAEG;;cAEe,QAAQ,CAAC,WAAW,CAAC;;;;;;;;;;;;;AA7CzC,wBAiDG"}

package/dist/types/components/RedisConfigurationList.vue.d.ts

@@ -0,0 +1,119 @@
+import type { PropType } from 'vue';
+import type { KonnectRedisConfigurationListConfig, KongManagerRedisConfigurationListConfig, EntityRow, CopyEventPayload } from '../types';
+import type { AxiosError } from 'axios';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** The base konnect or kongManger config. Pass additional config props in the shared entity component as needed. */
+    config: {
+        type: PropType<KonnectRedisConfigurationListConfig | KongManagerRedisConfigurationListConfig>;
+        required: true;
+        validator: (config: KonnectRedisConfigurationListConfig | KongManagerRedisConfigurationListConfig) => boolean;
+    };
+    cacheIdentifier: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** A synchronous or asynchronous function, that returns a boolean, that evaluates if the user can create a new entity */
+    canCreate: {
+        type: PropType<() => boolean | Promise<boolean>>;
+        required: false;
+        default: () => Promise<boolean>;
+    };
+    /** A synchronous or asynchronous function, that returns a boolean, that evaluates if the user can delete a given entity */
+    canDelete: {
+        type: PropType<(row: EntityRow) => boolean | Promise<boolean>>;
+        required: false;
+        default: () => Promise<boolean>;
+    };
+    /** A synchronous or asynchronous function, that returns a boolean, that evaluates if the user can edit a given entity */
+    canEdit: {
+        type: PropType<(row: EntityRow) => boolean | Promise<boolean>>;
+        required: false;
+        default: () => Promise<boolean>;
+    };
+    /** A synchronous or asynchronous function, that returns a boolean, that evaluates if the user can retrieve (view details) a given entity */
+    canRetrieve: {
+        type: PropType<(row: EntityRow) => boolean | Promise<boolean>>;
+        required: false;
+        default: () => Promise<boolean>;
+    };
+    /**
+     * Enables the new empty state design, this prop can be removed when
+     * the khcp-14756-empty-states-m2 FF is removed.
+     */
+    enableV2EmptyStates: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    error: (error: AxiosError<unknown, any>) => any;
+    "click:learn-more": () => any;
+    "click:plugin": (param: {
+        id: string;
+        plugin: string;
+    }) => any;
+    "copy:error": (payload: CopyEventPayload) => any;
+    "copy:success": (payload: CopyEventPayload) => any;
+    "delete:success": (key: EntityRow) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** The base konnect or kongManger config. Pass additional config props in the shared entity component as needed. */
+    config: {
+        type: PropType<KonnectRedisConfigurationListConfig | KongManagerRedisConfigurationListConfig>;
+        required: true;
+        validator: (config: KonnectRedisConfigurationListConfig | KongManagerRedisConfigurationListConfig) => boolean;
+    };
+    cacheIdentifier: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** A synchronous or asynchronous function, that returns a boolean, that evaluates if the user can create a new entity */
+    canCreate: {
+        type: PropType<() => boolean | Promise<boolean>>;
+        required: false;
+        default: () => Promise<boolean>;
+    };
+    /** A synchronous or asynchronous function, that returns a boolean, that evaluates if the user can delete a given entity */
+    canDelete: {
+        type: PropType<(row: EntityRow) => boolean | Promise<boolean>>;
+        required: false;
+        default: () => Promise<boolean>;
+    };
+    /** A synchronous or asynchronous function, that returns a boolean, that evaluates if the user can edit a given entity */
+    canEdit: {
+        type: PropType<(row: EntityRow) => boolean | Promise<boolean>>;
+        required: false;
+        default: () => Promise<boolean>;
+    };
+    /** A synchronous or asynchronous function, that returns a boolean, that evaluates if the user can retrieve (view details) a given entity */
+    canRetrieve: {
+        type: PropType<(row: EntityRow) => boolean | Promise<boolean>>;
+        required: false;
+        default: () => Promise<boolean>;
+    };
+    /**
+     * Enables the new empty state design, this prop can be removed when
+     * the khcp-14756-empty-states-m2 FF is removed.
+     */
+    enableV2EmptyStates: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onError?: ((error: AxiosError<unknown, any>) => any) | undefined;
+    "onClick:learn-more"?: (() => any) | undefined;
+    "onClick:plugin"?: ((param: {
+        id: string;
+        plugin: string;
+    }) => any) | undefined;
+    "onCopy:error"?: ((payload: CopyEventPayload) => any) | undefined;
+    "onCopy:success"?: ((payload: CopyEventPayload) => any) | undefined;
+    "onDelete:success"?: ((key: EntityRow) => any) | undefined;
+}>, {
+    cacheIdentifier: string;
+    canCreate: () => boolean | Promise<boolean>;
+    canDelete: (row: EntityRow) => boolean | Promise<boolean>;
+    canEdit: (row: EntityRow) => boolean | Promise<boolean>;
+    canRetrieve: (row: EntityRow) => boolean | Promise<boolean>;
+    enableV2EmptyStates: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=RedisConfigurationList.vue.d.ts.map

package/dist/types/components/RedisConfigurationList.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisConfigurationList.vue.d.ts","sourceRoot":"","sources":["../../../src/components/RedisConfigurationList.vue"],"names":[],"mappings":"AA2hBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AACnC,OAAO,KAAK,EACV,mCAAmC,EACnC,uCAAuC,EACvC,SAAS,EAET,gBAAgB,EACjB,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;;IAm7BrC,oHAAoH;;cAElG,QAAQ,CAAC,mCAAmC,GAAG,uCAAuC,CAAC;;4BAEnF,mCAAmC,GAAG,uCAAuC,KAAG,OAAO;;;;;;IAW7G,yHAAyH;;cAErG,QAAQ,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;;;IAI9D,2HAA2H;;cAEvG,QAAQ,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;;;IAI5E,yHAAyH;;cAErG,QAAQ,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;;;IAI5E,4IAA4I;;cAExH,QAAQ,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;;;IAI5E;;;OAGG;;;;;;;;;YAjD8B,MAAM;gBAAU,MAAM;;;;;;IAOvD,oHAAoH;;cAElG,QAAQ,CAAC,mCAAmC,GAAG,uCAAuC,CAAC;;4BAEnF,mCAAmC,GAAG,uCAAuC,KAAG,OAAO;;;;;;IAW7G,yHAAyH;;cAErG,QAAQ,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;;;IAI9D,2HAA2H;;cAEvG,QAAQ,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;;;IAI5E,yHAAyH;;cAErG,QAAQ,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;;;IAI5E,4IAA4I;;cAExH,QAAQ,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;;;IAI5E;;;OAGG;;;;;;;;;YAjD8B,MAAM;gBAAU,MAAM;;;;;;;qBAwBpB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;qBAM1B,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;mBAMxC,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;uBAMxC,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;;;AAjD7E,wBA8DG"}

package/dist/types/components/SentinelNodes.vue.d.ts

@@ -0,0 +1,14 @@
+import type { Identifiable, SentinelNode } from '../types';
+declare let __VLS_typeProps: {
+    readonly?: boolean;
+};
+type __VLS_PublicProps = {
+    modelValue: Identifiable<SentinelNode>[];
+} & typeof __VLS_typeProps;
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (modelValue: Identifiable<SentinelNode>[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((modelValue: Identifiable<SentinelNode>[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=SentinelNodes.vue.d.ts.map

package/dist/types/components/SentinelNodes.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SentinelNodes.vue.d.ts","sourceRoot":"","sources":["../../../src/components/SentinelNodes.vue"],"names":[],"mappings":"AA6FA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAK1D,QAAA,IAAI,eAAe,EAAG;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAC;AAqBF,KAAK,iBAAiB,GAAG;IACzB,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,EAAE,CAAC;CACxC,GAAG,OAAO,eAAe,CAAC;;;;;;AA0J3B,wBAOG"}

package/dist/types/composables/index.d.ts

@@ -0,0 +1,6 @@
+import useI18n from './useI18n';
+declare const _default: {
+    useI18n: typeof useI18n;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/composables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composables/index.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,WAAW,CAAA;;;;AAG/B,wBAEC"}

package/dist/types/composables/useI18n.d.ts

@@ -0,0 +1,9 @@
+import { createI18n, i18nTComponent } from '@kong-ui-public/i18n';
+import english from '../locales/en.json';
+interface UseI18nReturn {
+    i18n: ReturnType<typeof createI18n<typeof english>>;
+    i18nT: ReturnType<typeof i18nTComponent<typeof english>>;
+}
+export default function useI18n(): UseI18nReturn;
+export {};
+//# sourceMappingURL=useI18n.d.ts.map

package/dist/types/composables/useI18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useI18n.d.ts","sourceRoot":"","sources":["../../../src/composables/useI18n.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACjE,OAAO,OAAO,MAAM,oBAAoB,CAAA;AAExC,UAAU,aAAa;IACrB,IAAI,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAA;IACnD,KAAK,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC,CAAA;CACzD;AAED,MAAM,CAAC,OAAO,UAAU,OAAO,IAAI,aAAa,CAO/C"}

package/dist/types/composables/useLinkedPlugins.d.ts

@@ -0,0 +1,27 @@
+import { type KongManagerConfig, type KonnectConfig } from '@kong-ui-public/entities-shared';
+import type { RedisConfigurationLinkedPluginsResponse } from '../types';
+type RequestParams = {
+    partialId: string;
+    size?: number;
+    offset?: string | null;
+    query?: string;
+};
+export declare function buildLinksCacheKey(partialId: string): string;
+export declare const useLinkedPluginsFetcher: (config: KonnectConfig | KongManagerConfig) => {
+    fetcher: (params: RequestParams) => Promise<RedisConfigurationLinkedPluginsResponse>;
+};
+export declare const useLinkedPlugins: (param: {
+    partialId: string;
+    config: KonnectConfig | KongManagerConfig;
+    requestParams?: RequestParams;
+}) => import("vue").Ref<{
+    id: string;
+    name: string;
+    instance_name?: string | undefined;
+}[], import("../types").RedisConfigurationLinkedPlugin[] | {
+    id: string;
+    name: string;
+    instance_name?: string | undefined;
+}[]>;
+export {};
+//# sourceMappingURL=useLinkedPlugins.d.ts.map

package/dist/types/composables/useLinkedPlugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLinkedPlugins.d.ts","sourceRoot":"","sources":["../../../src/composables/useLinkedPlugins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAMtG,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,UAAU,CAAA;AAEvE,KAAK,aAAa,GAAG;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAA;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,UAEnD;AAED,eAAO,MAAM,uBAAuB,WAAY,aAAa,GAAG,iBAAiB;sBAIrD,aAAa;CAwBxC,CAAA;AAED,eAAO,MAAM,gBAAgB,UAAW;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,aAAa,GAAG,iBAAiB,CAAC;IAC1C,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;;;;;;;;IAkBA,CAAA"}

package/dist/types/composables/useRedisConfigurationForm.d.ts

@@ -0,0 +1,168 @@
+import { EntityBaseFormType } from '@kong-ui-public/entities-shared';
+import { RedisType } from '../types';
+import type { KongManagerRedisConfigurationFormConfig, KonnectRedisConfigurationFormConfig, RedisConfigurationResponse } from '../types';
+export type Options = {
+    partialId?: string;
+    defaultRedisType?: RedisType;
+    config: KonnectRedisConfigurationFormConfig | KongManagerRedisConfigurationFormConfig;
+};
+export declare const useRedisConfigurationForm: (options: Options) => {
+    form: {
+        fields: {
+            name: string;
+            type: import("../types").PartialType;
+            config: {
+                cluster_max_redirections: number;
+                cluster_nodes: {
+                    ip: string;
+                    port: number;
+                    id: string;
+                }[];
+                connect_timeout: number;
+                connection_is_proxied: boolean;
+                database: number;
+                host?: string | undefined;
+                keepalive_backlog: number;
+                keepalive_pool_size: number;
+                password: string;
+                port?: number | undefined;
+                read_timeout: number;
+                send_timeout: number;
+                sentinel_master?: string | undefined;
+                sentinel_nodes: {
+                    host: string;
+                    port: number;
+                    id: string;
+                }[];
+                sentinel_password: string;
+                sentinel_role?: ("master" | "slave" | "any") | undefined;
+                sentinel_username: string;
+                server_name?: string | undefined;
+                ssl_verify: boolean;
+                ssl: boolean;
+                timeout?: number | undefined;
+                username: string;
+            };
+        };
+        readonly: boolean;
+        errorMessage: string;
+    };
+    canSubmit: import("vue").ComputedRef<boolean | undefined>;
+    payload: import("vue").ComputedRef<{
+        name: string;
+        type: import("../types").PartialType;
+        config: {
+            host: string | undefined;
+            port: unknown;
+            timeout: unknown;
+            username: string | null;
+            database: unknown;
+            password: string | null;
+            ssl: boolean;
+            ssl_verify: boolean;
+            server_name: string | null;
+            connect_timeout?: undefined;
+            connection_is_proxied?: undefined;
+            keepalive_backlog?: undefined;
+            keepalive_pool_size?: undefined;
+            read_timeout?: undefined;
+            send_timeout?: undefined;
+            cluster_nodes?: undefined;
+            cluster_max_redirections?: undefined;
+            sentinel_master?: undefined;
+            sentinel_role?: undefined;
+            sentinel_nodes?: undefined;
+            sentinel_username?: undefined;
+            sentinel_password?: undefined;
+        };
+    } | {
+        name: string;
+        type: import("../types").PartialType;
+        config: {
+            connect_timeout: unknown;
+            connection_is_proxied: boolean;
+            database: unknown;
+            host: string | undefined;
+            keepalive_backlog: unknown;
+            keepalive_pool_size: unknown;
+            password: string | null;
+            port: unknown;
+            read_timeout: unknown;
+            send_timeout: unknown;
+            server_name: string | null;
+            ssl_verify: boolean;
+            ssl: boolean;
+            username: string | null;
+            cluster_nodes: null;
+            cluster_max_redirections: null;
+            sentinel_master: null;
+            sentinel_role: null;
+            sentinel_nodes: null;
+            sentinel_username: null;
+            sentinel_password: null;
+            timeout?: undefined;
+        };
+    } | {
+        name: string;
+        type: import("../types").PartialType;
+        config: {
+            cluster_nodes: import("../types").ClusterNode[];
+            cluster_max_redirections: unknown;
+            username: string | null;
+            password: string | null;
+            ssl: boolean;
+            ssl_verify: boolean;
+            server_name: string | null;
+            connect_timeout: unknown;
+            database: unknown;
+            send_timeout: unknown;
+            read_timeout: unknown;
+            keepalive_pool_size: unknown;
+            keepalive_backlog: unknown;
+            connection_is_proxied: null;
+            sentinel_master: null;
+            sentinel_role: null;
+            sentinel_nodes: null;
+            sentinel_username: null;
+            sentinel_password: null;
+            host: null;
+            port: null;
+            timeout?: undefined;
+        };
+    } | {
+        name: string;
+        type: import("../types").PartialType;
+        config: {
+            sentinel_master: string | null;
+            sentinel_nodes: import("../types").SentinelNode[];
+            sentinel_role: string | null;
+            sentinel_username: string | null;
+            sentinel_password: string | null;
+            username: string | null;
+            password: string | null;
+            ssl: boolean;
+            ssl_verify: boolean;
+            server_name: string | null;
+            database: unknown;
+            connect_timeout: unknown;
+            send_timeout: unknown;
+            read_timeout: unknown;
+            keepalive_pool_size: unknown;
+            keepalive_backlog: unknown;
+            connection_is_proxied: null;
+            cluster_nodes: null;
+            cluster_max_redirections: null;
+            host: null;
+            port: null;
+            timeout?: undefined;
+        };
+    }>;
+    isEdit: boolean;
+    redisType: import("vue").Ref<RedisType, RedisType>;
+    redisTypeIsEnterprise: import("vue").ComputedRef<boolean>;
+    formType: import("vue").ComputedRef<EntityBaseFormType>;
+    fetchUrl: import("vue").ComputedRef<string>;
+    submit: () => Promise<import("axios").AxiosResponse<RedisConfigurationResponse, any>>;
+    setInitialFormValues: (data: RedisConfigurationResponse) => void;
+};
+//# sourceMappingURL=useRedisConfigurationForm.d.ts.map

package/dist/types/composables/useRedisConfigurationForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedisConfigurationForm.d.ts","sourceRoot":"","sources":["../../../src/composables/useRedisConfigurationForm.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAuB,MAAM,iCAAiC,CAAA;AAIzF,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAIpC,OAAO,KAAK,EAAE,uCAAuC,EAAE,mCAAmC,EAAyD,0BAA0B,EAAE,MAAM,UAAU,CAAA;AAE/L,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,SAAS,CAAA;IAC5B,MAAM,EAAE,mCAAmC,GAAG,uCAAuC,CAAA;CACtF,CAAA;AAED,eAAO,MAAM,yBAAyB,YAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA4MpB,0BAA0B;CA2B/D,CAAA"}

package/dist/types/constants.d.ts

@@ -0,0 +1,7 @@
+import { RedisType } from './types';
+import type { ClusterNode, RedisConfigurationFormState, SentinelNode } from './types';
+export declare const DEFAULT_CLUSTER_NODE: Readonly<ClusterNode>;
+export declare const DEFAULT_SENTINEL_NODE: Readonly<SentinelNode>;
+export declare const DEFAULT_REDIS_TYPE = RedisType.HOST_PORT_CE;
+export declare const DEFAULT_FIELDS: Readonly<RedisConfigurationFormState['fields']['config']>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/types/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,2BAA2B,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAErF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAGtD,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,YAAY,CAGxD,CAAA;AAED,eAAO,MAAM,kBAAkB,yBAAyB,CAAA;AAExD,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAsBpF,CAAA"}

package/dist/types/helpers.d.ts

@@ -0,0 +1,20 @@
+import { PartialType, type ClusterNode, type Identifiable, type RedisConfigurationDTO, type RedisConfigurationFields, type SentinelNode } from './types';
+import { RedisType } from './types';
+export declare const shallowCopyWithId: <T extends Record<any, any>>(node: T) => Identifiable<T>;
+export declare const shallowCopyWithoutId: <T extends {
+    id: string;
+}>(node: T) => Omit<T, "id">;
+export declare const genDefaultSentinelNode: () => Identifiable<Readonly<SentinelNode>>;
+export declare const genDefaultClusterNode: () => Identifiable<Readonly<ClusterNode>>;
+export declare const getRedisType: (fields: RedisConfigurationFields | RedisConfigurationDTO) => RedisType;
+export declare const mapRedisTypeToPartialType: (type: RedisType) => PartialType;
+export declare const standardize: {
+    int<T>(value: string | number | undefined | null, defaultValue?: T): number | T;
+    str<T>(value: string | number | undefined | null, defaultValue?: T): string | T;
+    removeIdClusterNodes(nodes: Identifiable<ClusterNode>[]): ClusterNode[];
+    removeIdFromSentinelNodes(nodes: Identifiable<SentinelNode>[]): SentinelNode[];
+    addIdToClusterNodes(nodes: ClusterNode[]): Identifiable<ClusterNode>[];
+    addIdToSentinelNodes(nodes: SentinelNode[]): Identifiable<SentinelNode>[];
+    removeNullValues(obj: Record<string, any>): Record<string, any>;
+};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,qBAAqB,EAAE,KAAK,wBAAwB,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAA;AACxJ,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEnC,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,KAAG,YAAY,CAAC,CAAC,CAErF,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,QAAQ,CAAC,KAAG,IAAI,CAAC,CAAC,EAAE,IAAI,CAGpF,CAAA;AAED,eAAO,MAAM,sBAAsB,4CAAiD,CAAA;AAEpF,eAAO,MAAM,qBAAqB,2CAAgD,CAAA;AAElF,eAAO,MAAM,YAAY,WAAY,wBAAwB,GAAG,qBAAqB,KAAG,SAcvF,CAAA;AAED,eAAO,MAAM,yBAAyB,SAAU,SAAS,KAAG,WAE3D,CAAA;AAED,eAAO,MAAM,WAAW;QAClB,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,iBAAiB,CAAC,GAAG,MAAM,GAAG,CAAC;QAO3E,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,iBAAiB,CAAC,GAAG,MAAM,GAAG,CAAC;gCAOnD,YAAY,CAAC,WAAW,CAAC,EAAE,GAAG,WAAW,EAAE;qCAOtC,YAAY,CAAC,YAAY,CAAC,EAAE,GAAG,YAAY,EAAE;+BAOnD,WAAW,EAAE,GAAG,YAAY,CAAC,WAAW,CAAC,EAAE;gCAI1C,YAAY,EAAE,GAAG,YAAY,CAAC,YAAY,CAAC,EAAE;0BAInD,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAShE,CAAA"}

package/dist/types/index.d.ts

@@ -0,0 +1,40 @@
+import RedisConfigurationForm from './components/RedisConfigurationForm.vue';
+import RedisConfigurationList from './components/RedisConfigurationList.vue';
+import RedisConfigurationConfigCard from './components/RedisConfigurationConfigCard.vue';
+import LinkedPlugins from './components/LinkedPluginList.vue';
+import DeleteWarningModal from './components/DeleteWarningModal.vue';
+export { RedisConfigurationForm, RedisConfigurationList, RedisConfigurationConfigCard, LinkedPlugins, DeleteWarningModal, };
+export * from './types';
+import * as helpers from './helpers';
+export { helpers };
+import * as constants from './constants';
+export { constants };
+export declare const composables: {
+    useLinkedPlugins: (param: {
+        partialId: string;
+        config: import("@kong-ui-public/entities-shared").KonnectConfig | import("@kong-ui-public/entities-shared").KongManagerConfig;
+        requestParams?: {
+            partialId: string;
+            size?: number;
+            offset?: string | null;
+            query?: string;
+        };
+    }) => import("vue").Ref<{
+        id: string;
+        name: string;
+        instance_name?: string | undefined;
+    }[], import("./types").RedisConfigurationLinkedPlugin[] | {
+        id: string;
+        name: string;
+        instance_name?: string | undefined;
+    }[]>;
+    useLinkedPluginsFetcher: (config: import("@kong-ui-public/entities-shared").KonnectConfig | import("@kong-ui-public/entities-shared").KongManagerConfig) => {
+        fetcher: (params: {
+            partialId: string;
+            size?: number;
+            offset?: string | null;
+            query?: string;
+        }) => Promise<import("./types").RedisConfigurationLinkedPluginsResponse>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,MAAM,yCAAyC,CAAA;AAC5E,OAAO,sBAAsB,MAAM,yCAAyC,CAAA;AAC5E,OAAO,4BAA4B,MAAM,+CAA+C,CAAA;AACxF,OAAO,aAAa,MAAM,mCAAmC,CAAA;AAC7D,OAAO,kBAAkB,MAAM,qCAAqC,CAAA;AAEpE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,4BAA4B,EAC5B,aAAa,EACb,kBAAkB,GACnB,CAAA;AAED,cAAc,SAAS,CAAA;AAEvB,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AAEpC,OAAO,EAAE,OAAO,EAAE,CAAA;AAElB,OAAO,KAAK,SAAS,MAAM,aAAa,CAAA;AAExC,OAAO,EAAE,SAAS,EAAE,CAAA;AAOpB,eAAO,MAAM,WAAW;;;;qBAI+rB,CAAC;;;;;;;;;;;;;;;;;;;;;;;CADvtB,CAAA"}

package/dist/types/partials-endpoints.d.ts

@@ -0,0 +1,22 @@
+declare const _default: {
+    list: {
+        konnect: string;
+        kongManager: string;
+    };
+    form: {
+        konnect: {
+            create: string;
+            edit: string;
+        };
+        kongManager: {
+            create: string;
+            edit: string;
+        };
+    };
+    links: {
+        konnect: string;
+        kongManager: string;
+    };
+};
+export default _default;
+//# sourceMappingURL=partials-endpoints.d.ts.map

package/dist/types/partials-endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partials-endpoints.d.ts","sourceRoot":"","sources":["../../src/partials-endpoints.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA,wBAmBC"}

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

@@ -0,0 +1,6 @@
+export * from './redis-configuration';
+export * from './redis-configuration-form';
+export * from './redis-configuration-list';
+export * from './redis-configuration-config';
+export * from './redis-configuration-linked-plugins';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sCAAsC,CAAA"}

package/dist/types/types/redis-configuration-config.d.ts

@@ -0,0 +1,8 @@
+import type { KonnectBaseEntityConfig, KongManagerBaseEntityConfig } from '@kong-ui-public/entities-shared';
+/** Konnect redis configuration entity config */
+export interface KonnectRedisConfigurationEntityConfig extends KonnectBaseEntityConfig {
+}
+/** Kong Manager redis configuration entity config */
+export interface KongManagerRedisConfigurationEntityConfig extends KongManagerBaseEntityConfig {
+}
+//# sourceMappingURL=redis-configuration-config.d.ts.map

package/dist/types/types/redis-configuration-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-configuration-config.d.ts","sourceRoot":"","sources":["../../../src/types/redis-configuration-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,iCAAiC,CAAA;AAExC,gDAAgD;AAChD,MAAM,WAAW,qCAAsC,SAAQ,uBAAuB;CAAI;AAE1F,qDAAqD;AACrD,MAAM,WAAW,yCAA0C,SAAQ,2BAA2B;CAAI"}

package/dist/types/types/redis-configuration-form.d.ts

@@ -0,0 +1,40 @@
+import type { KonnectBaseFormConfig, KongManagerBaseFormConfig } from '@kong-ui-public/entities-shared';
+import type { ClusterNode, Identifiable, PartialType, SentinelNode } from './redis-configuration';
+export interface KonnectRedisConfigurationFormConfig extends KonnectBaseFormConfig {
+}
+export interface KongManagerRedisConfigurationFormConfig extends KongManagerBaseFormConfig {
+}
+export interface RedisConfigurationFields {
+    name: string;
+    type: PartialType;
+    config: {
+        cluster_max_redirections: number;
+        cluster_nodes: Identifiable<ClusterNode>[];
+        connect_timeout: number;
+        connection_is_proxied: boolean;
+        database: number;
+        host?: string;
+        keepalive_backlog: number;
+        keepalive_pool_size: number;
+        password: string;
+        port?: number;
+        read_timeout: number;
+        send_timeout: number;
+        sentinel_master?: string;
+        sentinel_nodes: Identifiable<SentinelNode>[];
+        sentinel_password: string;
+        sentinel_role?: 'master' | 'slave' | 'any';
+        sentinel_username: string;
+        server_name?: string;
+        ssl_verify: boolean;
+        ssl: boolean;
+        timeout?: number;
+        username: string;
+    };
+}
+export interface RedisConfigurationFormState {
+    fields: RedisConfigurationFields;
+    readonly: boolean;
+    errorMessage: string;
+}
+//# sourceMappingURL=redis-configuration-form.d.ts.map

package/dist/types/types/redis-configuration-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-configuration-form.d.ts","sourceRoot":"","sources":["../../../src/types/redis-configuration-form.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAA;AACvG,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEjG,MAAM,WAAW,mCAAoC,SAAQ,qBAAqB;CAAI;AACtF,MAAM,WAAW,uCAAwC,SAAQ,yBAAyB;CAAI;AAG9F,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,WAAW,CAAA;IACjB,MAAM,EAAE;QACN,wBAAwB,EAAE,MAAM,CAAA;QAChC,aAAa,EAAE,YAAY,CAAC,WAAW,CAAC,EAAE,CAAA;QAC1C,eAAe,EAAE,MAAM,CAAA;QACvB,qBAAqB,EAAE,OAAO,CAAA;QAC9B,QAAQ,EAAE,MAAM,CAAA;QAChB,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,iBAAiB,EAAE,MAAM,CAAA;QACzB,mBAAmB,EAAE,MAAM,CAAA;QAC3B,QAAQ,EAAE,MAAM,CAAA;QAChB,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,YAAY,EAAE,MAAM,CAAA;QACpB,YAAY,EAAE,MAAM,CAAA;QACpB,eAAe,CAAC,EAAE,MAAM,CAAA;QACxB,cAAc,EAAE,YAAY,CAAC,YAAY,CAAC,EAAE,CAAA;QAC5C,iBAAiB,EAAE,MAAM,CAAA;QACzB,aAAa,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAA;QAC1C,iBAAiB,EAAE,MAAM,CAAA;QACzB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,UAAU,EAAE,OAAO,CAAA;QACnB,GAAG,EAAE,OAAO,CAAA;QACZ,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;CACF;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,wBAAwB,CAAA;IAChC,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;CACrB"}