Objects

Objects definitions can include any combination of required, optional, defaultable named properties and index signatures.

Required Properties

string
fluent

const const symbolicKey: typeof symbolicKeysymbolicKey = Symbol()

const const myObject: Type<{
    requiredKey: string;
    [symbolicKey]: {
        nested: unknown;
    };
}>myObject = const type: TypeParser
<{
    readonly requiredKey: "string";
    readonly [symbolicKey]: {
        readonly nested: "unknown";
    };
}, Type<{
    requiredKey: string;
    [symbolicKey]: {
        nested: unknown;
    };
}, {}>>(def: validateObjectLiteral<{
    readonly requiredKey: "string";
    readonly [symbolicKey]: {
        readonly nested: "unknown";
    };
}, {}, bindThis<...>>) => Type<...> (+2 overloads)type({
	requiredKey: "string",
	// Nested definitions don't require additional `type` calls!
	[const symbolicKey: typeof symbolicKeysymbolicKey]: {
		nested: "unknown"
	}
})

const const symbolicKey: typeof symbolicKeysymbolicKey = Symbol()

const const myObject: Type<{
    requiredKey: string;
    [symbolicKey]: {
        nested: unknown;
    };
}>myObject = const type: TypeParser
<{
    readonly requiredKey: Type<string, {}>;
    readonly [symbolicKey]: {
        readonly nested: Type<unknown, {}>;
    };
}, Type<{
    requiredKey: string;
    [symbolicKey]: {
        nested: unknown;
    };
}, {}>>(def: validateObjectLiteral<...>) => Type<...> (+2 overloads)type({
	requiredKey: type.string,
	// Nested definitions don't require additional `type` calls!
	[const symbolicKey: typeof symbolicKeysymbolicKey]: {
		nested: type.unknown
	}
})

Optional Properties

const const symbolicKey: typeof symbolicKeysymbolicKey = Symbol()

const const myObject: Type<{
    [symbolicKey]: string.optional;
    optionalKey?: number[];
}>myObject = const type: TypeParser
<{
    readonly "optionalKey?": "number[]";
    readonly [symbolicKey]: "string?";
}, Type<{
    [symbolicKey]: string.optional;
    optionalKey?: number[];
}, {}>>(def: validateObjectLiteral<{
    readonly "optionalKey?": "number[]";
    readonly [symbolicKey]: "string?";
}, {}, bindThis<...>>) => Type<...> (+2 overloads)type({
	"optionalKey?": "number[]",
	[const symbolicKey: typeof symbolicKeysymbolicKey]: "string?"
})

const const symbolicKey: typeof symbolicKeysymbolicKey = Symbol()

const const myObject: Type<{
    optionalKey: of<number[], Optional>;
    [symbolicKey]: string.optional;
}>myObject = const type: TypeParser
<{
    readonly optionalKey: Type<of<number[], Optional>, {}>;
    readonly [symbolicKey]: Type<string.optional, {}>;
}, Type<{
    optionalKey: of<number[], Optional>;
    [symbolicKey]: string.optional;
}, {}>>(def: validateObjectLiteral<...>) => Type<...> (+2 overloads)type({
	optionalKey: type.number.array().optional(),
	[const symbolicKey: typeof symbolicKeysymbolicKey]: type.string.optional()
})

const const symbolicKey: typeof symbolicKeysymbolicKey = Symbol()

const const myObject: Type<{
    optionalKey: of<{
        type: "script";
    }, Optional>;
    [symbolicKey]: of<{
        ark: "type";
    }, Optional>;
}>myObject = const type: TypeParser
<{
    readonly optionalKey: readonly [{
        readonly type: "'script'";
    }, "?"];
    readonly [symbolicKey]: readonly [{
        readonly ark: "'type'";
    }, "?"];
}, Type<{
    optionalKey: of<{
        type: "script";
    }, Optional>;
    [symbolicKey]: of<...>;
}, {}>>(def: validateObjectLiteral<...>) => Type<...> (+2 overloads)type({
	optionalKey: [{ type: "'script'" }, "?"],
	[const symbolicKey: typeof symbolicKeysymbolicKey]: [{ ark: "'type'" }, "?"]
})

const const symbolicKey: typeof symbolicKeysymbolicKey = Symbol()

const const myObject: Type<{
    optionalKey: of<{
        type: "script";
    }, Optional>;
    [symbolicKey]: of<{
        ark: "type";
    }, Optional>;
}>myObject = const type: TypeParser
<{
    readonly optionalKey: Type<of<{
        type: "script";
    }, Optional>, {}>;
    readonly [symbolicKey]: Type<of<{
        ark: "type";
    }, Optional>, {}>;
}, Type<...>>(def: validateObjectLiteral<...>) => Type<...> (+2 overloads)type({
	optionalKey: const type: TypeParser
<{
    readonly type: "'script'";
}, "?", readonly [], Type<of<{
    type: "script";
}, Optional>, {}>>(_0: validateObjectLiteral<{
    readonly type: "'script'";
}, {}, bindThis<{
    readonly type: "'script'";
}>>, _1: "?") => Type<...> (+2 overloads)type({ type: "'script'" }, "?"),
	[const symbolicKey: typeof symbolicKeysymbolicKey]: const type: TypeParser
<{
    readonly ark: "'type'";
}, "?", readonly [], Type<of<{
    ark: "type";
}, Optional>, {}>>(_0: validateObjectLiteral<{
    readonly ark: "'type'";
}, {}, bindThis<{
    readonly ark: "'type'";
}>>, _1: "?") => Type<...> (+2 overloads)type({ ark: "'type'" }, "?")
})

Adding a optional or default to a Type doesn’t alter its standalone behavior.

Rather, it adds metadata that changes how it works when referenced from an object or tuple.

See an example

const const optionalString: Type<string.optional>optionalString = type.string.optional()

const optionalString: Type<string.optional>optionalString.allows(undefined) // false

const const objectWithOptionalKey: Type<{
    foo: string.optional;
}>objectWithOptionalKey = const type: TypeParser
<{
    readonly foo: Type<string.optional, {}>;
}, Type<{
    foo: string.optional;
}, {}>>(def: validateObjectLiteral<{
    readonly foo: Type<string.optional, {}>;
}, {}, bindThis<...>>) => Type<...> (+2 overloads)type({
	foo: const optionalString: Type<string.optional>optionalString
})

const objectWithOptionalKey: Type<{
    foo: string.optional;
}>objectWithOptionalKey.allows({}) // true

Prefer the key-embedded syntax ("optionalKey?":) where possible.

Defaultable Properties

const const myObject: Type<{
    defaultableKey: of<boolean, Default<false>>;
}>myObject = const type: TypeParser
<{
    readonly defaultableKey: "boolean = false";
}, Type<{
    defaultableKey: of<boolean, Default<false>>;
}, {}>>(def: validateObjectLiteral<{
    readonly defaultableKey: "boolean = false";
}, {}, bindThis<...>>) => Type<...> (+2 overloads)type({
	defaultableKey: "boolean = false"
})

const const myObject: Type<{
    defaultableKey: of<boolean, Default<false>>;
}>myObject = const type: TypeParser
<{
    readonly defaultableKey: Type<of<boolean, Default<false>>, {}>;
}, Type<{
    defaultableKey: of<boolean, Default<false>>;
}, {}>>(def: validateObjectLiteral<{
    readonly defaultableKey: Type<of<boolean, Default<false>>, {}>;
}, {}, bindThis<...>>) => Type<...> (+2 overloads)type({
	defaultableKey: type.boolean.default(false)
})

const const myObject: Type<{
    defaultableKey: of<boolean, Default<false>>;
}>myObject = const type: TypeParser
<{
    readonly defaultableKey: readonly ["boolean", "=", false];
}, Type<{
    defaultableKey: of<boolean, Default<false>>;
}, {}>>(def: validateObjectLiteral<{
    readonly defaultableKey: readonly ["boolean", "=", false];
}, {}, bindThis<...>>) => Type<...> (+2 overloads)type({
	defaultableKey: ["boolean", "=", false]
})

const const myObject: Type<{
    defaultableKey: of<boolean, Default<false>>;
}>myObject = const type: TypeParser
<{
    readonly defaultableKey: Type<of<boolean, Default<false>>, {}>;
}, Type<{
    defaultableKey: of<boolean, Default<false>>;
}, {}>>(def: validateObjectLiteral<{
    readonly defaultableKey: Type<of<boolean, Default<false>>, {}>;
}, {}, bindThis<...>>) => Type<...> (+2 overloads)type({
	defaultableKey: const type: TypeParser
<"boolean", "=", readonly [false], Type<of<boolean, Default<false>>, {}>>(_0: "boolean", _1: "=", _2_0: DefaultFor<boolean>) => Type<of<boolean, Default<false>>, {}> (+2 overloads)type("boolean", "=", false)
})

Index Signatures

string

const const myObject: Type<{
    [x: string]: number | integer;
    [x: symbol]: number;
}>myObject = const type: TypeParser
<{
    readonly "[string]": "number.integer";
    readonly "[string | symbol]": "number";
}, Type<{
    [x: string]: number | integer;
    [x: symbol]: number;
}, {}>>(def: validateObjectLiteral<{
    readonly "[string]": "number.integer";
    readonly "[string | symbol]": "number";
}, {}, bindThis<...>>) => Type<...> (+2 overloads)type({
	// index signatures do not require a label
	"[string]": "number.integer",
	// arbitrary string or symbolic expressions are allowed
	"[string | symbol]": "number"
})