Best way to pass `Type` around

import { type Type, type, validateAmbient } from "arktype";
import { type ErrorMessage } from "@ark/util";

type ValidateArguments<T> = {
  [K in keyof T]: {
    type: validateAmbient<T[K]>;
  };
};

type ArkType = Type | Type<(_: any) => any>;

type InferredArkType<T> = T extends ArkType
  ? T["infer"]
  : ErrorMessage<"invalid Ark type">;

type ParseArguments<T> = {
  [K in keyof T]: InferredArkType<T[K]>;
};

type Command<T> = {
  arguments: ValidateArguments<T>;
  run(args: ParseArguments<T>): void | Promise<void>;
};

function defineCommand<const conf>(command: Command<conf>) {
  console.log(command);
}

defineCommand({
  arguments: {
    a: {
      type: type(`string>2`),
    },
    b: {
      type: type("string").narrow((address, ctx) => {
        if (address === [...address].reverse().join("")) {
          return true;
        }
        return ctx.mustBe("a palindrome");
      }),
    },
    c: {
      type: type(["string", "=>", parseFloat]),
    },
    d: {
      type: type("string.json").pipe.try(
        (s): object => JSON.parse(s),
        type({
          name: "string",
          version: "string.semver",
        })
      ),
    },
    f: {
      type: type("string|undefined"),
    },
  },
  run(args) {
    args.a;
    //   ^?
    args.b;
    //   ^?
    args.c;
    //   ^?
    args.d;
    //   ^?
    args.f;
    //   ^?
  },
});