@kong-ui-public/entities-upstreams-targets 3.7.31-pr.2132.c7fba69a4.0 → 3.7.31

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

@@ -0,0 +1,43 @@
+import { type PropType } from 'vue';
+import type { AxiosError } from 'axios';
+import '@kong-ui-public/entities-shared/dist/style.css';
+import type { KongManagerUpstreamsFormConfig, KonnectUpstreamsFormConfig, UpstreamResponse } from '../types';
+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<KonnectUpstreamsFormConfig | KongManagerUpstreamsFormConfig>;
+        required: true;
+        validator: (config: KonnectUpstreamsFormConfig | KongManagerUpstreamsFormConfig) => boolean;
+    };
+    /** If a valid upstreamId is provided, it will put the form in Edit mode instead of Create */
+    upstreamId: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    error: (error: AxiosError<unknown, any>) => any;
+    update: (data: UpstreamResponse) => any;
+    loading: (isLoading: boolean) => 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<KonnectUpstreamsFormConfig | KongManagerUpstreamsFormConfig>;
+        required: true;
+        validator: (config: KonnectUpstreamsFormConfig | KongManagerUpstreamsFormConfig) => boolean;
+    };
+    /** If a valid upstreamId is provided, it will put the form in Edit mode instead of Create */
+    upstreamId: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>> & Readonly<{
+    onError?: ((error: AxiosError<unknown, any>) => any) | undefined;
+    onUpdate?: ((data: UpstreamResponse) => any) | undefined;
+    onLoading?: ((isLoading: boolean) => any) | undefined;
+}>, {
+    upstreamId: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UpstreamsForm.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UpstreamsForm.vue.d.ts","sourceRoot":"","sources":["../../../src/components/UpstreamsForm.vue"],"names":[],"mappings":"AAwfA,OAAO,EAAsB,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAA;AAEvD,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,OAAO,CAAA;AAatD,OAAO,gDAAgD,CAAA;AACvD,OAAO,KAAK,EACV,8BAA8B,EAC9B,0BAA0B,EAM1B,gBAAgB,EAEjB,MAAM,UAAU,CAAA;;IAooBf,oHAAoH;;cAElG,QAAQ,CAAC,0BAA0B,GAAG,8BAA8B,CAAC;;4BAEjE,0BAA0B,GAAG,8BAA8B,KAAG,OAAO;;IAQ3F,6FAA6F;;;;;;;;;;;IAZ7F,oHAAoH;;cAElG,QAAQ,CAAC,0BAA0B,GAAG,8BAA8B,CAAC;;4BAEjE,0BAA0B,GAAG,8BAA8B,KAAG,OAAO;;IAQ3F,6FAA6F;;;;;;;;;;;;;AAvB/F,wBA8BG"}

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

@@ -0,0 +1,153 @@
+import type { PropType } from 'vue';
+import type { ActiveHealthCheckHeader, HealthCheckType, KongManagerUpstreamsFormConfig, KonnectUpstreamsFormConfig } from '../types';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<KonnectUpstreamsFormConfig | KongManagerUpstreamsFormConfig>;
+        required: true;
+    };
+    type: {
+        type: PropType<HealthCheckType>;
+        required: true;
+    };
+    httpPath: {
+        type: StringConstructor;
+        required: true;
+    };
+    timeout: {
+        type: StringConstructor;
+        required: true;
+    };
+    concurrency: {
+        type: StringConstructor;
+        required: true;
+    };
+    httpsSni: {
+        type: StringConstructor;
+        required: true;
+    };
+    verifySsl: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    headers: {
+        type: PropType<ActiveHealthCheckHeader[]>;
+        required: true;
+    };
+    healthyInterval: {
+        type: StringConstructor;
+        required: true;
+    };
+    healthySuccesses: {
+        type: StringConstructor;
+        required: true;
+    };
+    healthyHttpStatuses: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    unhealthyInterval: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyHttpFailures: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyTcpFailures: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyHttpStatuses: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    unhealthyTimeouts: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: any;
+} & {
+    [x: string]: any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<KonnectUpstreamsFormConfig | KongManagerUpstreamsFormConfig>;
+        required: true;
+    };
+    type: {
+        type: PropType<HealthCheckType>;
+        required: true;
+    };
+    httpPath: {
+        type: StringConstructor;
+        required: true;
+    };
+    timeout: {
+        type: StringConstructor;
+        required: true;
+    };
+    concurrency: {
+        type: StringConstructor;
+        required: true;
+    };
+    httpsSni: {
+        type: StringConstructor;
+        required: true;
+    };
+    verifySsl: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    headers: {
+        type: PropType<ActiveHealthCheckHeader[]>;
+        required: true;
+    };
+    healthyInterval: {
+        type: StringConstructor;
+        required: true;
+    };
+    healthySuccesses: {
+        type: StringConstructor;
+        required: true;
+    };
+    healthyHttpStatuses: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    unhealthyInterval: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyHttpFailures: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyTcpFailures: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyHttpStatuses: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    unhealthyTimeouts: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{
+    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+}>, {
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UpstreamsFormActiveHealthCheck.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UpstreamsFormActiveHealthCheck.vue.d.ts","sourceRoot":"","sources":["../../../src/components/UpstreamsFormActiveHealthCheck.vue"],"names":[],"mappings":"AA+gBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AAEnC,OAAO,KAAK,EACV,uBAAuB,EACvB,eAAe,EACY,8BAA8B,EACzD,0BAA0B,EAC3B,MAAM,UAAU,CAAA;;;cAqmCG,QAAQ,CAAC,0BAA0B,GAAG,8BAA8B,CAAC;;;;cAIrE,QAAQ,CAAC,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;cAwB1B,QAAQ,CAAC,uBAAuB,EAAE,CAAC;;;;;;;;;;;;cAYnC,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;cAgBlB,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;;;cAxDjB,QAAQ,CAAC,0BAA0B,GAAG,8BAA8B,CAAC;;;;cAIrE,QAAQ,CAAC,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;cAwB1B,QAAQ,CAAC,uBAAuB,EAAE,CAAC;;;;;;;;;;;;cAYnC,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;cAgBlB,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;;AAhFrC,wBA6FG"}

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

@@ -0,0 +1,69 @@
+import type { PropType } from 'vue';
+import type { KongManagerUpstreamsFormConfig, KonnectUpstreamsFormConfig } from '../types';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<KonnectUpstreamsFormConfig | KongManagerUpstreamsFormConfig>;
+        required: true;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    hostHeader: {
+        type: StringConstructor;
+        required: true;
+    };
+    clientCertificate: {
+        type: StringConstructor;
+        required: true;
+    };
+    tags: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:name": (val: string) => any;
+    "update:host-header": (val: string) => any;
+    "update:client-certificate": (val: string) => any;
+    "update:tags": (val: string) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    config: {
+        type: PropType<KonnectUpstreamsFormConfig | KongManagerUpstreamsFormConfig>;
+        required: true;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    hostHeader: {
+        type: StringConstructor;
+        required: true;
+    };
+    clientCertificate: {
+        type: StringConstructor;
+        required: true;
+    };
+    tags: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:name"?: ((val: string) => any) | undefined;
+    "onUpdate:host-header"?: ((val: string) => any) | undefined;
+    "onUpdate:client-certificate"?: ((val: string) => any) | undefined;
+    "onUpdate:tags"?: ((val: string) => any) | undefined;
+}>, {
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UpstreamsFormGeneralInfo.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UpstreamsFormGeneralInfo.vue.d.ts","sourceRoot":"","sources":["../../../src/components/UpstreamsFormGeneralInfo.vue"],"names":[],"mappings":"AAoOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AAEnC,OAAO,KAAK,EAAE,8BAA8B,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAA;;;cA0etE,QAAQ,CAAC,0BAA0B,GAAG,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArE,QAAQ,CAAC,0BAA0B,GAAG,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAbzF,wBAsCG"}

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

@@ -0,0 +1,49 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    activeHealthSwitch: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    passiveHealthSwitch: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    healthchecksThreshold: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:active-health-switch": (val: boolean) => any;
+    "update:passive-health-switch": (val: boolean) => any;
+    "update:healthchecks-threshold": (val: string) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    activeHealthSwitch: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    passiveHealthSwitch: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    healthchecksThreshold: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:active-health-switch"?: ((val: boolean) => any) | undefined;
+    "onUpdate:passive-health-switch"?: ((val: boolean) => any) | undefined;
+    "onUpdate:healthchecks-threshold"?: ((val: string) => any) | undefined;
+}>, {
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UpstreamsFormHealthChecks.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UpstreamsFormHealthChecks.vue.d.ts","sourceRoot":"","sources":["../../../src/components/UpstreamsFormHealthChecks.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoYA,wBA6BG"}

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

@@ -0,0 +1,121 @@
+import type { PropType } from 'vue';
+import type { UpstreamAlgorithm, UpstreamHash } from '../types';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    algorithm: {
+        type: PropType<UpstreamAlgorithm>;
+        required: true;
+    };
+    slots: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOn: {
+        type: PropType<UpstreamHash>;
+        required: true;
+    };
+    hashFallback: {
+        type: PropType<UpstreamHash>;
+        required: true;
+    };
+    hashOnHeader: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOnCookie: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOnCookiePath: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOnQueryArgument: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOnUriCapture: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashFallbackHeader: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashFallbackQueryArgument: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashFallbackUriCapture: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: any;
+} & {
+    [x: string]: any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    algorithm: {
+        type: PropType<UpstreamAlgorithm>;
+        required: true;
+    };
+    slots: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOn: {
+        type: PropType<UpstreamHash>;
+        required: true;
+    };
+    hashFallback: {
+        type: PropType<UpstreamHash>;
+        required: true;
+    };
+    hashOnHeader: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOnCookie: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOnCookiePath: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOnQueryArgument: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashOnUriCapture: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashFallbackHeader: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashFallbackQueryArgument: {
+        type: StringConstructor;
+        required: true;
+    };
+    hashFallbackUriCapture: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{
+    [x: `on${Capitalize<any>}`]: ((...args: any) => any) | undefined;
+}>, {
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UpstreamsFormLoadBalancing.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UpstreamsFormLoadBalancing.vue.d.ts","sourceRoot":"","sources":["../../../src/components/UpstreamsFormLoadBalancing.vue"],"names":[],"mappings":"AAqdA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AAEnC,OAAO,KAAK,EAAuC,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;;;cAs5BhF,QAAQ,CAAC,iBAAiB,CAAC;;;;;;;;cAQ3B,QAAQ,CAAC,YAAY,CAAC;;;;cAItB,QAAQ,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAZtB,QAAQ,CAAC,iBAAiB,CAAC;;;;;;;;cAQ3B,QAAQ,CAAC,YAAY,CAAC;;;;cAItB,QAAQ,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAjC1C,wBA0EG"}

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

@@ -0,0 +1,91 @@
+import type { PropType } from 'vue';
+import type { HealthCheckType } from '../types';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    type: {
+        type: PropType<HealthCheckType>;
+        required: true;
+    };
+    healthySuccesses: {
+        type: StringConstructor;
+        required: true;
+    };
+    healthyHttpStatuses: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    unhealthyTimeouts: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyHttpFailures: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyHttpStatuses: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    unhealthyTcpFailures: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:type": (val: HealthCheckType) => any;
+    "update:healthy-successes": (val: string) => any;
+    "update:healthy-http-statuses": (val: string[]) => any;
+    "update:unhealthy-http-failures": (val: string) => any;
+    "update:unhealthy-tcp-failures": (val: string) => any;
+    "update:unhealthy-http-statuses": (val: string[]) => any;
+    "update:unhealthy-timeouts": (val: string) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: PropType<HealthCheckType>;
+        required: true;
+    };
+    healthySuccesses: {
+        type: StringConstructor;
+        required: true;
+    };
+    healthyHttpStatuses: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    unhealthyTimeouts: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyHttpFailures: {
+        type: StringConstructor;
+        required: true;
+    };
+    unhealthyHttpStatuses: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    unhealthyTcpFailures: {
+        type: StringConstructor;
+        required: true;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:type"?: ((val: HealthCheckType) => any) | undefined;
+    "onUpdate:healthy-successes"?: ((val: string) => any) | undefined;
+    "onUpdate:healthy-http-statuses"?: ((val: string[]) => any) | undefined;
+    "onUpdate:unhealthy-http-failures"?: ((val: string) => any) | undefined;
+    "onUpdate:unhealthy-tcp-failures"?: ((val: string) => any) | undefined;
+    "onUpdate:unhealthy-http-statuses"?: ((val: string[]) => any) | undefined;
+    "onUpdate:unhealthy-timeouts"?: ((val: string) => any) | undefined;
+}>, {
+    readonly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UpstreamsFormPassiveHealthCheck.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UpstreamsFormPassiveHealthCheck.vue.d.ts","sourceRoot":"","sources":["../../../src/components/UpstreamsFormPassiveHealthCheck.vue"],"names":[],"mappings":"AAsRA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AAEnC,OAAO,KAAK,EAAE,eAAe,EAA6B,MAAM,UAAU,CAAA;;;cA0lBtD,QAAQ,CAAC,eAAe,CAAC;;;;;;;;cAQ1B,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;;;;;;cAYlB,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;cApBjB,QAAQ,CAAC,eAAe,CAAC;;;;;;;;cAQ1B,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;;;;;;cAYlB,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;AApCrC,wBAiDG"}

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

@@ -0,0 +1,123 @@
+import type { PropType } from 'vue';
+import type { AxiosError } from 'axios';
+import type { KongManagerUpstreamsListConfig, KonnectUpstreamsListConfig, EntityRow, CopyEventPayload } from '../types';
+import '@kong-ui-public/entities-shared/dist/style.css';
+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<KonnectUpstreamsListConfig | KongManagerUpstreamsListConfig>;
+        required: true;
+        validator: (config: KonnectUpstreamsListConfig | KongManagerUpstreamsListConfig) => 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>;
+    };
+    /** default to false, setting to true will teleport the toolbar button to the destination in the consuming app */
+    useActionOutside: {
+        type: BooleanConstructor;
+        default: 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;
+    "copy:success": (payload: CopyEventPayload) => any;
+    "copy:error": (payload: CopyEventPayload) => any;
+    "delete:success": (upstream: 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<KonnectUpstreamsListConfig | KongManagerUpstreamsListConfig>;
+        required: true;
+        validator: (config: KonnectUpstreamsListConfig | KongManagerUpstreamsListConfig) => 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>;
+    };
+    /** default to false, setting to true will teleport the toolbar button to the destination in the consuming app */
+    useActionOutside: {
+        type: BooleanConstructor;
+        default: 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;
+    "onCopy:success"?: ((payload: CopyEventPayload) => any) | undefined;
+    "onCopy:error"?: ((payload: CopyEventPayload) => any) | undefined;
+    "onDelete:success"?: ((upstream: 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>;
+    useActionOutside: boolean;
+    enableV2EmptyStates: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=UpstreamsList.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UpstreamsList.vue.d.ts","sourceRoot":"","sources":["../../../src/components/UpstreamsList.vue"],"names":[],"mappings":"AAikBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAA;AAEnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAGvC,OAAO,KAAK,EACV,8BAA8B,EAC9B,0BAA0B,EAC1B,SAAS,EACT,gBAAgB,EACjB,MAAM,UAAU,CAAA;AAYjB,OAAO,gDAAgD,CAAA;;IAy9BrD,oHAAoH;;cAElG,QAAQ,CAAC,0BAA0B,GAAG,8BAA8B,CAAC;;4BAEjE,0BAA0B,GAAG,8BAA8B,KAAG,OAAO;;;;;;IAY3F,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,iHAAiH;;;;;IAKjH;;;OAGG;;;;;;;;;;;;IAhDH,oHAAoH;;cAElG,QAAQ,CAAC,0BAA0B,GAAG,8BAA8B,CAAC;;4BAEjE,0BAA0B,GAAG,8BAA8B,KAAG,OAAO;;;;;;IAY3F,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,iHAAiH;;;;;IAKjH;;;OAGG;;;;;;;;;;;;;qBA9BgC,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,wBAmEG"}