Aetae

interface Some {
  value: string | string[];
}

const foo = {
  value: ['a', 'b'] // здесь всегда будет массив
} satisfies Some;

foo.value.map(() => {}); // ок

TS7053: Element implicitly has an 'any' type because expression of type 'RouteRecordName' can't be used to index type '{ first: string; second: string; }'.   No index signature with a parameter of type 'string' was found on type '{ first: string; second: string; }'.

const pages: Record<PropertyKey, string> = {
  first: 'Первая',
  second: 'Вторая',
  ...
}

export enum ERoutes {
  FIRST = 'first',
  SECOND = 'second'
}

const routes = [
  {
     name: ERoutes.FIRST,
     ...
  },
  {
     name: ERoutes.SECOND,
     ...
  },
  ...
]

const pages: Record<ERoutes, string> = {
  [ERoutes.FIRST]: 'Первая',
  [ERoutes.SECOND]: 'Вторая',
  ...
}

... = pages[route.name as ERoutes]

const routes = [
  {
     name: 'first',
     ...
  },
  {
     name: 'second',
     ...
  },
  ...
] as const satisfies ReadonlyArray<ReadonlyRouteRecordRaw>;

type ReadonlyRouteRecordRaw = Omit<RouteRecordRaw, 'children'> & {
  children?: ReadonlyArray<ReadonlyRouteRecordRaw>;
};

type ExtractNames<Route> = Route extends { name: infer Name } ? Name : never;
type FlattenChildren<Route> = Route extends { children: ReadonlyArray<infer Children> }
  ? FlattenChildren<Children> | Route
  : Route;

// с помощью магии ts вытаскиваем в тип RouteNames все заданные у нас имена маршрутов
export type RouteNames = ExtractNames<FlattenChildren<typeof routes[number]>>;

// с помощью магии же прокидывем их прямо в декларацию vue-router
declare module 'vue-router' {
  export interface RouteLocationNormalizedLoaded {
    name: RouteNames | null | undefined;
  }
}

const narrowRoutesTypeWrapper = <T extends ReadonlyArray<ReadonlyRouteRecordRaw>>(routes: T) => routes;
const routes = narrowRoutesTypeWrapper([ ... ] as const);

const pages: Record<RouteNames, string> = {
  first: 'Первая',
  second: 'Вторая',
  ...
}

type ITableColumn<
  DataInterface extends object, 
  Keys extends keyof DataInterface = keyof DataInterface
> = {
  [K in Keys]: {
    key: K;
    title: React.ReactNode;
    hasSort?: boolean;
    render?: (item: DataInterface[K]) => React.ReactNode;
  }
}[Keys];

о какой рендер функции идет речь?

<template>
  <div>
    <render/>
  </div>
</template>

<script setup lang="ts">
  import { h, useSlots } from 'vue'

  const slots = useSlots();
  const render = () => {
    return h('div', slots.default());
  };
</script>

class DistinctBehaviorSubject<T> extends BehaviorSubject<T> {
  next(value: T) {
    if (this.value !== value)
    	super.next(value);
  }
}

function doSomething(param: string, value: unknown) {
  console.log('doSomething', param, value);
}

function WebworkerParam(param: string){
  return (target: any, key: PropertyKey) => {
    let subscription: Subscription;
    let innerValue: any;

    Object.defineProperty(target, key, {
      get() {
        return innerValue;
      },
      set(value) {
        if (subscription)
          subscription.unsubscribe();

        if(value instanceof BehaviorSubject)
          subscription = value.subscribe(newValue => doSomething(param, newValue));
        else 
          doSomething(param, value);

        innerValue = value; 
      }   
    })
  }
}

class User {}

interface Types {
  number: number;
  dog: string; 
  user: User
}

function add<K extends keyof Types>(type: K): Types[K] {}

type MethodNames<T extends string> = `get${T}s` | `create${T}` | `get${T}`;

interface IAPI {
  new <T extends string>(type: T, url: string): {
    [K in MethodNames<T>]: Function
  }
}

export default API as unknown as IAPI;

type MethodNames<T extends string> = `get${T}s` | `create${T}` | `get${T}`;
class API {
  [key: MethodNames<string>]: Function

  _url;

  constructor(type: string, url: string) {
    this._url = url;

    this[`get${type}s`] = this._readMany;
    this[`create${type}`] = this._create;
    this[`get${type}`] = this._read;
  }

  _readMany(params = {}) {
    const options = getApiOptions(Method.GET);
    const url = new URL(this._url);
    url.search = new URLSearchParams(params);
    
    return fetch(url.toString(), options);
  }

  _create(body) {
    const options = getApiOptions(Method.POST, body);
    
    return fetch(this._url, options);
  }

  _read(id) {
    const options = getApiOptions(Method.GET);
    
    return fetch(`${this._url}/{id}`, options);
  }
}

const createdFromNow = `Created ${
  moment.duration(moment().diff(data.createdAt)).humanize()
} ago`;