TypeScript classless DI container design

config.ts

import { container, scopes } from "./library"
import { ListUsers, listUsersFactory } from "./listUsers"
import { UserRepositoryInterface } from "./UserRepoistoryInterface"
import { userRepositoryFactory } from "./userResistory"

const users = [{id: 1, name: "user1"}];
container.bind<UserRepositoryInterface>().toFactory(userRepositoryFactory, {users}).in(scopes.GLOBAL)
container.bind<ListUsers>().toFactory(listUsersFactory).in(scopes.GLOBAL)

handler.ts

import { ListUsers } from "./listUsers";

const requestHandlerFactory = ({
  listUsers
}: {listUsers: ListUsers}) =>
  (request: Request, response: Response): void => {
    const users = listUsers();
    response.send(users);
  }

export default requestHandlerFactory;

library.ts

export type Factory<T, Dep extends object> = ({...dependencies}: Dep) => T;

export type Scope = "global" | "request" | "transient";

export const scopes = {
  GLOBAL: "global" as Scope,
  REQUEST: "request" as Scope,
  TRANSIENT: "transient" as Scope
}
export type Builder<T> = {
  to(instance: T): Builder<T>
  factory<Dep extends object>(factory: Factory<T, Dep>): Builder<T>
  scope(scope: Scope): Builder<T>
}

const bind: <T>() => Builder<T> = <T>() => ({
  to(): Builder<T> {
    throw new Error("not implemented");
  },
  factory(): Builder<T> {
    throw new Error("not implemented");
  },
  scope(): Builder<T> {
    throw new Error("not implemented");
  }
})

const get: <T>() => T = <T>() => {
  throw new Error("not implemented");
}

export const container = {
  get,
  bind
}

listUsers.ts

import { UserRepositoryInterface } from "./UserRepoistoryInterface";

export const listUsersFactory = ({userRepository}: {userRepository: UserRepositoryInterface}) =>
  () => userRepository.list()

export type ListUsers = ReturnType<typeof listUsersFactory>;

userRepository.ts

import { User, UserRepositoryInterface } from "./UserRepoistoryInterface";

export const userRepositoryFactory = ({users}: {users: User[]}) => (
  {
    list: () => users
  }
)

UserRepositoryInterface.ts

export type User = {
  id: number
  name: string
}

export interface UserRepositoryInterface {
  list(): User[]
}