@caido-utils/components 0.1.0

package/dist/HttpqlInput/suggestions.js

@@ -0,0 +1,325 @@
+const NAMESPACES = [
+  { value: "req", description: "Request" },
+  { value: "resp", description: "Response" },
+  { value: "row", description: "Row identifier" },
+  { value: "filter", description: "Custom filter" }
+];
+const REQ_FIELDS = [
+  { value: "created_at", description: "Created at" },
+  { value: "ext", description: "File extension" },
+  { value: "host", description: "Host" },
+  { value: "len", description: "Length" },
+  { value: "method", description: "Method" },
+  { value: "path", description: "Path" },
+  { value: "port", description: "Port" },
+  { value: "query", description: "Query" },
+  { value: "raw", description: "Entire content" },
+  { value: "tls", description: "Is TLS" }
+];
+const RESP_FIELDS = [
+  { value: "code", description: "Status code" },
+  { value: "len", description: "Length" },
+  { value: "raw", description: "Entire content" },
+  { value: "roundtrip", description: "Round trip time" }
+];
+const ROW_FIELDS = [{ value: "id", description: "Row ID" }];
+const FILTER_VALUES = [
+  { value: "inscope", description: "In-scope requests" },
+  { value: "recent", description: "Recent requests" },
+  { value: "1hr", description: "Last hour" },
+  { value: "6hr", description: "Last 6 hours" },
+  { value: "12hr", description: "Last 12 hours" },
+  { value: "24hr", description: "Last 24 hours" }
+];
+const FIELD_TYPES = {
+  // req
+  "req.created_at": "datetime",
+  "req.ext": "string",
+  "req.host": "string",
+  "req.len": "integer",
+  "req.method": "string",
+  "req.path": "string",
+  "req.port": "integer",
+  "req.query": "string",
+  "req.raw": "string",
+  "req.tls": "boolean",
+  // resp
+  "resp.code": "integer",
+  "resp.len": "integer",
+  "resp.raw": "string",
+  "resp.roundtrip": "integer",
+  // row
+  "row.id": "integer"
+};
+const STRING_OPERATORS = [
+  { value: "eq", description: "Equals" },
+  { value: "ne", description: "Not equals" },
+  { value: "cont", description: "Contains" },
+  { value: "ncont", description: "Not contains" },
+  { value: "like", description: "Like" },
+  { value: "nlike", description: "Not like" },
+  { value: "regex", description: "Regex" },
+  { value: "nregex", description: "Not regex" }
+];
+const INTEGER_OPERATORS = [
+  { value: "eq", description: "Equals" },
+  { value: "ne", description: "Not equals" },
+  { value: "gt", description: "Greater than" },
+  { value: "gte", description: "Greater or equal" },
+  { value: "lt", description: "Less than" },
+  { value: "lte", description: "Less or equal" }
+];
+const DATETIME_OPERATORS = [
+  { value: "gt", description: "After" },
+  { value: "lt", description: "Before" }
+];
+const BOOLEAN_OPERATORS = [
+  { value: "eq", description: "Equals" },
+  { value: "ne", description: "Not equals" }
+];
+const LOGICAL_OPERATORS = [
+  { value: "AND", description: "Both match" },
+  { value: "OR", description: "Either matches" }
+];
+function getOperatorsForType(type) {
+  switch (type) {
+    case "string":
+      return STRING_OPERATORS;
+    case "integer":
+      return INTEGER_OPERATORS;
+    case "datetime":
+      return DATETIME_OPERATORS;
+    case "boolean":
+      return BOOLEAN_OPERATORS;
+  }
+}
+export function getSuggestions(query, cursorPos) {
+  const before = query.slice(0, cursorPos).trimStart();
+  const empty = {
+    category: "",
+    items: [],
+    partial: "",
+    suffix: ""
+  };
+  if (!before.trim()) {
+    return {
+      category: "Namespaces",
+      items: [...NAMESPACES],
+      partial: "",
+      suffix: "."
+    };
+  }
+  const lastBoundary = Math.max(
+    before.lastIndexOf(" "),
+    before.lastIndexOf("	"),
+    before.lastIndexOf("(")
+  );
+  const currentToken = before.slice(lastBoundary + 1);
+  const preceding = before.slice(0, lastBoundary + 1).trimEnd();
+  if (currentToken.includes('"') || currentToken.includes("'")) {
+    return empty;
+  }
+  const beforeTrimmed = before.trimEnd();
+  if (beforeTrimmed.endsWith('"') || beforeTrimmed.endsWith("'") || beforeTrimmed.endsWith(")")) {
+    return {
+      category: "Logical",
+      items: [...LOGICAL_OPERATORS],
+      partial: currentToken,
+      suffix: " "
+    };
+  }
+  function handleNamespaceToken(ns, fields, nsLen) {
+    if (!currentToken.startsWith(ns + ".")) return null;
+    const rest = currentToken.slice(nsLen + 1);
+    const dotIdx = rest.indexOf(".");
+    if (dotIdx !== -1) {
+      const fieldName = rest.slice(0, dotIdx);
+      const fullField = ns + "." + fieldName;
+      if (fullField in FIELD_TYPES) {
+        const afterDot = rest.slice(dotIdx + 1);
+        if (afterDot.includes(":")) return empty;
+        const fieldType = FIELD_TYPES[fullField];
+        const operators = getOperatorsForType(fieldType);
+        return {
+          category: "Operators",
+          items: operators.filter(
+            (op) => op.value.startsWith(afterDot.toLowerCase())
+          ),
+          partial: afterDot,
+          suffix: ":"
+        };
+      }
+    }
+    return {
+      category: "Fields",
+      items: fields.filter((f) => f.value.startsWith(rest)),
+      partial: rest,
+      suffix: "."
+    };
+  }
+  const nsResult = handleNamespaceToken("req", REQ_FIELDS, 3) ?? handleNamespaceToken("resp", RESP_FIELDS, 4) ?? handleNamespaceToken("row", ROW_FIELDS, 3);
+  if (nsResult) return nsResult;
+  if (currentToken.startsWith("filter:")) {
+    const rest = currentToken.slice(7);
+    const items = FILTER_VALUES.filter(
+      (f) => f.value.startsWith(rest.toLowerCase()) && f.value !== rest.toLowerCase()
+    );
+    if (items.length === 0) return empty;
+    return {
+      category: "Filters",
+      items,
+      partial: rest,
+      suffix: " "
+    };
+  }
+  if (currentToken === "filter") {
+    return { category: "", items: [{ value: ":" }], partial: "", suffix: "" };
+  }
+  const upperPreceding = preceding.toUpperCase();
+  if (!preceding || upperPreceding.endsWith("AND") || upperPreceding.endsWith("OR") || preceding.endsWith("(")) {
+    const filtered2 = NAMESPACES.filter(
+      (ns) => ns.value.startsWith(currentToken.toLowerCase())
+    );
+    if (filtered2.length > 0) {
+      return {
+        category: "Namespaces",
+        items: filtered2,
+        partial: currentToken,
+        suffix: "."
+      };
+    }
+  }
+  const lastPrecedingSpace = preceding.trimEnd().lastIndexOf(" ");
+  const precedingToken = preceding.trimEnd().slice(lastPrecedingSpace + 1).toLowerCase();
+  if (precedingToken in FIELD_TYPES) {
+    const fieldType = FIELD_TYPES[precedingToken];
+    const operators = getOperatorsForType(fieldType);
+    const filtered2 = operators.filter(
+      (op) => op.value.startsWith(currentToken.toLowerCase())
+    );
+    return {
+      category: "Operators",
+      items: filtered2,
+      partial: currentToken,
+      suffix: " "
+    };
+  }
+  const allOperators = [
+    ...STRING_OPERATORS,
+    ...INTEGER_OPERATORS,
+    ...DATETIME_OPERATORS,
+    ...BOOLEAN_OPERATORS
+  ];
+  if (allOperators.some((op) => op.value === precedingToken)) {
+    return empty;
+  }
+  const filtered = LOGICAL_OPERATORS.filter(
+    (op) => op.value.toUpperCase().startsWith(currentToken.toUpperCase())
+  );
+  if (filtered.length > 0 && currentToken.length > 0) {
+    return {
+      category: "Logical",
+      items: filtered,
+      partial: currentToken,
+      suffix: " "
+    };
+  }
+  return empty;
+}
+const ALL_OPERATORS = /* @__PURE__ */ new Set([
+  "eq",
+  "ne",
+  "cont",
+  "ncont",
+  "like",
+  "nlike",
+  "regex",
+  "nregex",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+]);
+const LOGICAL_SET = /* @__PURE__ */ new Set(["AND", "OR"]);
+const NAMESPACE_PREFIXES = ["req", "resp", "row", "filter"];
+const FIELD_PATTERN = /^(req|resp|row)(\..*)?$/;
+const FILTER_PATTERN = /^filter(:.*)?\s*$/;
+export function tokenize(query) {
+  const tokens = [];
+  let i = 0;
+  while (i < query.length) {
+    if (query[i] === " " || query[i] === "	") {
+      let start2 = i;
+      while (i < query.length && (query[i] === " " || query[i] === "	")) i++;
+      tokens.push({ type: "text", text: query.slice(start2, i) });
+      continue;
+    }
+    if (query[i] === "(" || query[i] === ")") {
+      tokens.push({ type: "paren", text: query[i] });
+      i++;
+      continue;
+    }
+    if (query[i] === '"' || query[i] === "'") {
+      const quote = query[i];
+      let start2 = i;
+      i++;
+      while (i < query.length && query[i] !== quote) {
+        if (query[i] === "\\") i++;
+        i++;
+      }
+      if (i < query.length) i++;
+      tokens.push({ type: "value", text: query.slice(start2, i) });
+      continue;
+    }
+    let start = i;
+    while (i < query.length && query[i] !== " " && query[i] !== "	" && query[i] !== "(" && query[i] !== ")") {
+      if ((query[i] === '"' || query[i] === "'") && i > start && query[i - 1] === ":") {
+        const quote = query[i];
+        i++;
+        while (i < query.length && query[i] !== quote) {
+          if (query[i] === "\\") i++;
+          i++;
+        }
+        if (i < query.length) i++;
+        continue;
+      }
+      i++;
+    }
+    const word = query.slice(start, i);
+    if (LOGICAL_SET.has(word) || LOGICAL_SET.has(word.toUpperCase())) {
+      tokens.push({ type: "logical", text: word });
+    } else if (ALL_OPERATORS.has(word.toLowerCase())) {
+      tokens.push({ type: "operator", text: word });
+    } else if (FIELD_PATTERN.test(word) || FILTER_PATTERN.test(word) || word === "filter") {
+      const inlineMatch = word.match(
+        /^((?:req|resp|row)\.[^.]+)\.(\w+)(?::([\s\S]*))?$/
+      );
+      if (inlineMatch) {
+        const [, field, op, val] = inlineMatch;
+        tokens.push({ type: "field", text: field });
+        tokens.push({ type: "text", text: "." });
+        if (val !== void 0) {
+          tokens.push({ type: "operator", text: op });
+          tokens.push({ type: "text", text: ":" });
+          tokens.push({ type: "value", text: val });
+        } else {
+          tokens.push({ type: "operator", text: op });
+        }
+      } else if (FILTER_PATTERN.test(word) && word.includes(":")) {
+        const colonIdx = word.indexOf(":");
+        tokens.push({ type: "field", text: word.slice(0, colonIdx) });
+        tokens.push({ type: "text", text: ":" });
+        tokens.push({ type: "value", text: word.slice(colonIdx + 1) });
+      } else {
+        tokens.push({ type: "field", text: word });
+      }
+    } else if (/^\d+$/.test(word)) {
+      tokens.push({ type: "value", text: word });
+    } else if (NAMESPACE_PREFIXES.some((ns) => ns.startsWith(word.toLowerCase()))) {
+      tokens.push({ type: "field", text: word });
+    } else {
+      tokens.push({ type: "text", text: word });
+    }
+  }
+  return tokens;
+}

package/dist/Menu/Container.d.vue.ts

@@ -0,0 +1,11 @@
+declare function show(event: Event | {
+    currentTarget: HTMLElement | undefined;
+}): void;
+declare function hide(): void;
+declare function toggle(event: Event): void;
+declare const _default: import("vue").DefineComponent<{}, {
+    show: typeof show;
+    hide: typeof hide;
+    toggle: typeof toggle;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/dist/Menu/Container.vue

@@ -0,0 +1,40 @@
+<script setup lang="ts">
+import TieredMenu from "primevue/tieredmenu";
+import type { MenuItem } from "primevue/menuitem";
+import { ref } from "vue";
+
+defineProps<{
+  items: MenuItem[];
+}>();
+
+const menuRef = ref<InstanceType<typeof TieredMenu>>();
+
+function show(event: Event | { currentTarget: HTMLElement | undefined }) {
+  menuRef.value?.show(event);
+}
+
+function hide() {
+  menuRef.value?.hide();
+}
+
+function toggle(event: Event) {
+  menuRef.value?.toggle(event);
+}
+
+defineExpose({ show, hide, toggle });
+
+const menuPt = {
+  itemContent: { class: "!bg-transparent hover:!bg-surface-700" },
+};
+</script>
+
+<template>
+  <TieredMenu
+    ref="menuRef"
+    :model="items"
+    popup
+    appendTo="body"
+    class="border border-surface-600 shadow-lg text-sm"
+    :pt="menuPt"
+  />
+</template>

package/dist/Menu/Container.vue.d.ts

@@ -0,0 +1,11 @@
+declare function show(event: Event | {
+    currentTarget: HTMLElement | undefined;
+}): void;
+declare function hide(): void;
+declare function toggle(event: Event): void;
+declare const _default: import("vue").DefineComponent<{}, {
+    show: typeof show;
+    hide: typeof hide;
+    toggle: typeof toggle;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/dist/MenuButton/Container.d.vue.ts

@@ -0,0 +1,43 @@
+import type { MenuItem } from "primevue/menuitem";
+type __VLS_Props = {
+    items: MenuItem[];
+    label?: string;
+    icon?: string;
+    severity?: string;
+    size?: "small" | "large" | undefined;
+    disabled?: boolean;
+};
+declare function toggle(event: Event): void;
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    severity: string;
+    size: string;
+    disabled: boolean;
+}>, {
+    toggle: typeof toggle;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    severity: string;
+    size: string;
+    disabled: boolean;
+}>>>, {
+    size: "small" | "large";
+    severity: string;
+    disabled: boolean;
+}, {}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/MenuButton/Container.vue

@@ -0,0 +1,42 @@
+<script setup lang="ts">
+import Button from "primevue/button";
+import type { MenuItem } from "primevue/menuitem";
+import { ref } from "vue";
+import Menu from "../Menu/Container.vue";
+
+withDefaults(
+  defineProps<{
+    items: MenuItem[];
+    label?: string;
+    icon?: string;
+    severity?: string;
+    size?: "small" | "large" | undefined;
+    disabled?: boolean;
+  }>(),
+  {
+    severity: "contrast",
+    size: "small",
+    disabled: false,
+  },
+);
+
+const menuRef = ref<InstanceType<typeof Menu>>();
+
+function toggle(event: Event) {
+  menuRef.value?.toggle(event);
+}
+
+defineExpose({ toggle });
+</script>
+
+<template>
+  <Button
+    :label="label"
+    :icon="icon"
+    :severity="severity"
+    :size="size"
+    :disabled="disabled"
+    @click="toggle"
+  />
+  <Menu ref="menuRef" :items="items" />
+</template>

package/dist/MenuButton/Container.vue.d.ts

@@ -0,0 +1,43 @@
+import type { MenuItem } from "primevue/menuitem";
+type __VLS_Props = {
+    items: MenuItem[];
+    label?: string;
+    icon?: string;
+    severity?: string;
+    size?: "small" | "large" | undefined;
+    disabled?: boolean;
+};
+declare function toggle(event: Event): void;
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    severity: string;
+    size: string;
+    disabled: boolean;
+}>, {
+    toggle: typeof toggle;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    severity: string;
+    size: string;
+    disabled: boolean;
+}>>>, {
+    size: "small" | "large";
+    severity: string;
+    disabled: boolean;
+}, {}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/MultiSelect/Container.d.vue.ts

@@ -0,0 +1,54 @@
+type __VLS_Props = {
+    modelValue: unknown[];
+    options: unknown[];
+    optionLabel?: string;
+    optionValue?: string;
+    placeholder?: string;
+    display?: "comma" | "chip";
+    filter?: boolean;
+    showToggleAll?: boolean;
+    disabled?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    optionLabel: string;
+    optionValue: string;
+    placeholder: string;
+    display: string;
+    filter: boolean;
+    showToggleAll: boolean;
+    disabled: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    optionLabel: string;
+    optionValue: string;
+    placeholder: string;
+    display: string;
+    filter: boolean;
+    showToggleAll: boolean;
+    disabled: boolean;
+}>>>, {
+    filter: boolean;
+    placeholder: string;
+    disabled: boolean;
+    optionLabel: string;
+    optionValue: string;
+    display: "comma" | "chip";
+    showToggleAll: boolean;
+}, {}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/MultiSelect/Container.vue

@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import PrimeMultiSelect from "primevue/multiselect";
+import { computed } from "vue";
+
+const props = withDefaults(
+  defineProps<{
+    modelValue: unknown[];
+    options: unknown[];
+    optionLabel?: string;
+    optionValue?: string;
+    placeholder?: string;
+    display?: "comma" | "chip";
+    filter?: boolean;
+    showToggleAll?: boolean;
+    disabled?: boolean;
+  }>(),
+  {
+    optionLabel: "label",
+    optionValue: "value",
+    placeholder: "Select...",
+    display: "chip",
+    filter: false,
+    showToggleAll: false,
+    disabled: false,
+  },
+);
+
+const emit = defineEmits<{
+  "update:modelValue": [value: unknown[]];
+}>();
+
+const pt = computed(() => ({
+  label: { style: "padding: 0.25rem 0.5rem; font-size: 0.75rem;" },
+  chipItem: { style: "padding: 0; font-size: 0.75rem;" },
+  pcChip: {
+    root: { style: "padding: 0.1rem 0.4rem; font-size: 0.7rem;" },
+  },
+}));
+</script>
+
+<template>
+  <PrimeMultiSelect
+    :model-value="modelValue"
+    :options="options"
+    :option-label="optionLabel"
+    :option-value="optionValue"
+    :placeholder="placeholder"
+    :display="display"
+    :filter="filter"
+    :show-toggle-all="showToggleAll"
+    :disabled="disabled"
+    :pt="pt"
+    size="small"
+    v-bind="$attrs"
+    @update:model-value="emit('update:modelValue', $event)"
+  />
+</template>

package/dist/MultiSelect/Container.vue.d.ts

@@ -0,0 +1,54 @@
+type __VLS_Props = {
+    modelValue: unknown[];
+    options: unknown[];
+    optionLabel?: string;
+    optionValue?: string;
+    placeholder?: string;
+    display?: "comma" | "chip";
+    filter?: boolean;
+    showToggleAll?: boolean;
+    disabled?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    optionLabel: string;
+    optionValue: string;
+    placeholder: string;
+    display: string;
+    filter: boolean;
+    showToggleAll: boolean;
+    disabled: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    optionLabel: string;
+    optionValue: string;
+    placeholder: string;
+    display: string;
+    filter: boolean;
+    showToggleAll: boolean;
+    disabled: boolean;
+}>>>, {
+    filter: boolean;
+    placeholder: string;
+    disabled: boolean;
+    optionLabel: string;
+    optionValue: string;
+    display: "comma" | "chip";
+    showToggleAll: boolean;
+}, {}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};