Incorrect Type when using type.declare<>()

[eralmansouri]

Using type.declare<Expected>().type({...}) returns a validator that results in an incorrect type when used.

Let's say we defined these two identical validators.

type Expected = { a: number; b?: number }
const Type_with_declare = type.declare<Expected, { side: "out" }>().type({
    a: "string.numeric.parse",
    "b?": "number"
})

const Type_without_declare = type({
    a: "string.numeric.parse",
    "b?": "number"
});

When used, they return different types. Despite the fact that their actual returned values being identical. Essentially, their runtime behavior is still as expected but it's returned Type does not correctly represent it.

// typed as '((In: {a: string; b?: number;}) => Expected) | ArkErrors'
const result_with_declare = Type_with_declare({
    a: "3"
});

// typed as '{a: number; b?: number;} | ArkErrors'
const result_without_declare = Type_without_declare({
    a: "3"
});

In both cases, the actual result is { a: 3 } as expected.

🧩 Context

• ArkType version: 2.1.29
• TypeScript version (5.1+): 5.9.3

🧑‍💻 Repro

Playground Link: Here

[gregg-cbs]

Yeah it seems like declare is not working at all. Glad a fix is coming.

[gregg-cbs]

Another declare bug for you:

type Addresses = {
 display_name: string
}[]

const t = declare<Addresses>().type({
    display_name: "string",
  }).array() // i would expect to put .array() here because it is an array of results

// ^^ this returns the following type:
const t: Type<({
    display_name: string;
    formatted_address: string;
    place_id: string;
}[] | undefined)[], {}>

^^ Note the double array brackets [], one for the object and then one for the entire type.

[eralmansouri]

Another declare bug for you:

type Addresses = {
display_name: string
}[]

const t = declare().type({
display_name: "string",
}).array() // i would expect to put .array() here because it is an array of results

// ^^ this returns the following type:
const t: Type<({
display_name: string;
formatted_address: string;
place_id: string;
}[] | undefined)[], {}>
^^ Note the double array brackets [], one for the object and then one for the entire type.

@gregg-cbs I'm not sure that should work to begin with, regardless of the bug reported here. Your type {display_name: "string", formatted_address: "string", place_id: "string"} does not match your Expected type {display_name: string}[].

Notice that .array() comes after you've already created the type, so the type itself needs to have already fulfilled the Expected type, so already we know this shouldn't work because your Expected type is an array. Also, as far as I know, declare<>() does not give you the ability to define "subtypes" like that. The only type that fulfills Expected would be exactly {display_name: string}[], adding formatted_address and place_id would be an error anyways. My fix does not affect your implementation here.

If the additional fields are mostly a mistake (since they are only in the inferred type in your example and not in the actual code), I think you might want to do something like this instead:

import { declare } from "arktype"

type Address = {
 display_name: string
};

const Thing = declare<Address>().type({
  display_name: "string",
}).array();


const out = Thing([{display_name: "Home Address" }]);

This kinda gives you the Address typing and converting it to an array after. Hopefully that works. If you really need the type to be an array type to begin with, then maybe an intermediate type can help.

import { declare } from "arktype"

type Address = {
 display_name: string
};

type Addresses = Address[];

const _intermediate = declare<Address>().type({
  display_name: "string",
});

const Thing = declare<Addresses>().type(_intermediate.array());

const out = Thing([{display_name: "Home Address" }]);

Good luck.