@reactionary/core 0.0.27

package/src/index.d.ts

@@ -0,0 +1,36 @@
+export * from './cache/caching-strategy';
+export * from './cache/redis-cache';
+export * from './client/client';
+export * from './providers/analytics.provider';
+export * from './providers/base.provider';
+export * from './providers/cart.provider';
+export * from './providers/identity.provider';
+export * from './providers/inventory.provider';
+export * from './providers/price.provider';
+export * from './providers/product.provider';
+export * from './providers/search.provider';
+export * from './schemas/capabilities.schema';
+export * from './schemas/session.schema';
+export * from './schemas/models/base.model';
+export * from './schemas/models/cart.model';
+export * from './schemas/models/currency.model';
+export * from './schemas/models/identifiers.model';
+export * from './schemas/models/identity.model';
+export * from './schemas/models/inventory.model';
+export * from './schemas/models/price.model';
+export * from './schemas/models/product.model';
+export * from './schemas/models/search.model';
+export * from './schemas/mutations/base.mutation';
+export * from './schemas/mutations/cart.mutation';
+export * from './schemas/mutations/identity.mutation';
+export * from './schemas/mutations/inventory.mutation';
+export * from './schemas/mutations/price.mutation';
+export * from './schemas/mutations/product.mutation';
+export * from './schemas/mutations/search.mutation';
+export * from './schemas/queries/base.query';
+export * from './schemas/queries/cart.query';
+export * from './schemas/queries/identity.query';
+export * from './schemas/queries/inventory.query';
+export * from './schemas/queries/price.query';
+export * from './schemas/queries/product.query';
+export * from './schemas/queries/search.query';

package/src/providers/analytics.provider.d.ts

@@ -0,0 +1,6 @@
+import { AnalyticsEvent } from '../schemas/models/analytics.model';
+import { AnalyticsMutation } from '../schemas/mutations/analytics.mutation';
+import { AnalyticsQuery } from '../schemas/queries/analytics.query';
+import { BaseProvider } from './base.provider';
+export declare abstract class AnalyticsProvider<T extends AnalyticsEvent = AnalyticsEvent, Q extends AnalyticsQuery = AnalyticsQuery, M extends AnalyticsMutation = AnalyticsMutation> extends BaseProvider<T, Q, M> {
+}

package/src/providers/base.provider.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { Session } from '../schemas/session.schema';
+import { BaseQuery } from '../schemas/queries/base.query';
+import { BaseMutation } from '../schemas/mutations/base.mutation';
+import { BaseModel } from '../schemas/models/base.model';
+/**
+ * Base capability provider, responsible for mutations (changes) and queries (fetches)
+ * for a given business object domain.
+ */
+export declare abstract class BaseProvider<T extends BaseModel = BaseModel, Q extends BaseQuery = BaseQuery, M extends BaseMutation = BaseMutation> {
+    readonly schema: z.ZodType<T>;
+    readonly querySchema: z.ZodType<Q, Q>;
+    readonly mutationSchema: z.ZodType<M, M>;
+    constructor(schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    /**
+     * Validates that the final domain model constructed by the provider
+     * fulfills the schema as defined. This will throw an exception.
+     */
+    protected assert(value: T): T;
+    /**
+     * Creates a new model entity based on the schema defaults.
+     */
+    protected newModel(): T;
+    /**
+     * Retrieves a set of entities matching the list of queries. The size of
+     * the resulting list WILL always match the size of the query list. The
+     * result list will never contain nulls or undefined. The order
+     * of the results will match the order of the queries.
+     */
+    query(queries: Q[], session: Session): Promise<T[]>;
+    /**
+     * Executes the listed mutations in order and returns the final state
+     * resulting from that set of operations.
+     */
+    mutate(mutations: M[], session: Session): Promise<T>;
+    /**
+     * The internal extension point for providers implementating query
+     * capabilities.
+     */
+    protected abstract fetch(queries: Q[], session: Session): Promise<T[]>;
+    /**
+     * The internal extension point for providers implementing mutation
+     * capabilities.
+     */
+    protected abstract process(mutations: M[], session: Session): Promise<T>;
+}

package/src/providers/cart.provider.d.ts

@@ -0,0 +1,6 @@
+import { CartQuery } from "../schemas/queries/cart.query";
+import { CartMutation } from "../schemas/mutations/cart.mutation";
+import { BaseProvider } from "./base.provider";
+import { Cart } from "../schemas/models/cart.model";
+export declare abstract class CartProvider<T extends Cart = Cart, Q extends CartQuery = CartQuery, M extends CartMutation = CartMutation> extends BaseProvider<T, Q, M> {
+}

package/src/providers/identity.provider.d.ts

@@ -0,0 +1,6 @@
+import { Identity } from "../schemas/models/identity.model";
+import { IdentityQuery } from "../schemas/queries/identity.query";
+import { IdentityMutation } from "../schemas/mutations/identity.mutation";
+import { BaseProvider } from "./base.provider";
+export declare abstract class IdentityProvider<T extends Identity = Identity, Q extends IdentityQuery = IdentityQuery, M extends IdentityMutation = IdentityMutation> extends BaseProvider<T, Q, M> {
+}

package/src/providers/inventory.provider.d.ts

@@ -0,0 +1,6 @@
+import { Inventory } from '../schemas/models/inventory.model';
+import { InventoryQuery } from '../schemas/queries/inventory.query';
+import { InventoryMutation } from '../schemas/mutations/inventory.mutation';
+import { BaseProvider } from './base.provider';
+export declare abstract class InventoryProvider<T extends Inventory = Inventory, Q extends InventoryQuery = InventoryQuery, M extends InventoryMutation = InventoryMutation> extends BaseProvider<T, Q, M> {
+}

package/src/providers/price.provider.d.ts

@@ -0,0 +1,6 @@
+import { Price } from '../schemas/models/price.model';
+import { PriceMutation } from '../schemas/mutations/price.mutation';
+import { PriceQuery } from '../schemas/queries/price.query';
+import { BaseProvider } from './base.provider';
+export declare abstract class PriceProvider<T extends Price = Price, Q extends PriceQuery = PriceQuery, M extends PriceMutation = PriceMutation> extends BaseProvider<T, Q, M> {
+}

package/src/providers/product.provider.d.ts

@@ -0,0 +1,6 @@
+import { Product } from '../schemas/models/product.model';
+import { ProductMutation } from '../schemas/mutations/product.mutation';
+import { ProductQuery } from '../schemas/queries/product.query';
+import { BaseProvider } from './base.provider';
+export declare abstract class ProductProvider<T extends Product = Product, Q extends ProductQuery = ProductQuery, M extends ProductMutation = ProductMutation> extends BaseProvider<T, Q, M> {
+}

package/src/providers/search.provider.d.ts

@@ -0,0 +1,6 @@
+import { SearchResult } from '../schemas/models/search.model';
+import { SearchQuery } from '../schemas/queries/search.query';
+import { SearchMutation } from '../schemas/mutations/search.mutation';
+import { BaseProvider } from './base.provider';
+export declare abstract class SearchProvider<T extends SearchResult = SearchResult, Q extends SearchQuery = SearchQuery, M extends SearchMutation = SearchMutation> extends BaseProvider<T, Q, M> {
+}

package/src/schemas/capabilities.schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const CapabilitiesSchema: z.ZodInterface<{
+    product: z.ZodBoolean;
+    search: z.ZodBoolean;
+    analytics: z.ZodBoolean;
+    identity: z.ZodBoolean;
+    cart: z.ZodBoolean;
+    inventory: z.ZodBoolean;
+    price: z.ZodBoolean;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type Capabilities = z.infer<typeof CapabilitiesSchema>;

package/src/schemas/models/analytics.model.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const AnalyticsEventSchema: z.MergeInterfaces<z.ZodInterface<{
+    meta: z.ZodDefault<z.ZodInterface<{
+        cache: z.ZodDefault<z.ZodInterface<{
+            hit: z.ZodDefault<z.ZodBoolean>;
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        placeholder: z.ZodDefault<z.ZodBoolean>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export type AnalyticsEvent = z.infer<typeof AnalyticsEventSchema>;

package/src/schemas/models/base.model.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const CacheInformationSchema: z.ZodInterface<{
+    hit: z.ZodDefault<z.ZodBoolean>;
+    key: z.ZodDefault<z.ZodString>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const MetaSchema: z.ZodInterface<{
+    cache: z.ZodDefault<z.ZodInterface<{
+        hit: z.ZodDefault<z.ZodBoolean>;
+        key: z.ZodDefault<z.ZodString>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+    placeholder: z.ZodDefault<z.ZodBoolean>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const BaseModelSchema: z.ZodInterface<{
+    meta: z.ZodDefault<z.ZodInterface<{
+        cache: z.ZodDefault<z.ZodInterface<{
+            hit: z.ZodDefault<z.ZodBoolean>;
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        placeholder: z.ZodDefault<z.ZodBoolean>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type CacheInformation = z.infer<typeof CacheInformationSchema>;
+export type Meta = z.infer<typeof MetaSchema>;
+export type BaseModel = z.infer<typeof BaseModelSchema>;

package/src/schemas/models/cart.model.d.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+export declare const CartItemSchema: z.ZodInterface<{
+    identifier: z.ZodDefault<z.ZodInterface<{
+        key: z.ZodDefault<z.ZodString>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+    product: z.ZodDefault<z.ZodInterface<{
+        key: z.ZodDefault<z.ZodString>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+    quantity: z.ZodDefault<z.ZodNumber>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const CartSchema: z.MergeInterfaces<z.ZodInterface<{
+    meta: z.ZodDefault<z.ZodInterface<{
+        cache: z.ZodDefault<z.ZodInterface<{
+            hit: z.ZodDefault<z.ZodBoolean>;
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        placeholder: z.ZodDefault<z.ZodBoolean>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    identifier: z.ZodDefault<z.ZodInterface<{
+        key: z.ZodDefault<z.ZodString>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+    items: z.ZodDefault<z.ZodArray<z.ZodInterface<{
+        identifier: z.ZodDefault<z.ZodInterface<{
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        product: z.ZodDefault<z.ZodInterface<{
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        quantity: z.ZodDefault<z.ZodNumber>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export type CartItem = z.infer<typeof CartItemSchema>;
+export type Cart = z.infer<typeof CartSchema>;

package/src/schemas/models/currency.model.d.ts

@@ -0,0 +1,185 @@
+import { z } from 'zod';
+export declare const CurrencySchema: z.ZodEnum<{
+    AED: "AED";
+    AFN: "AFN";
+    ALL: "ALL";
+    AMD: "AMD";
+    ANG: "ANG";
+    AOA: "AOA";
+    ARS: "ARS";
+    AUD: "AUD";
+    AWG: "AWG";
+    AZN: "AZN";
+    BAM: "BAM";
+    BBD: "BBD";
+    BDT: "BDT";
+    BGN: "BGN";
+    BHD: "BHD";
+    BIF: "BIF";
+    BMD: "BMD";
+    BND: "BND";
+    BOB: "BOB";
+    BOV: "BOV";
+    BRL: "BRL";
+    BSD: "BSD";
+    BTN: "BTN";
+    BWP: "BWP";
+    BYN: "BYN";
+    BZD: "BZD";
+    CAD: "CAD";
+    CDF: "CDF";
+    CHE: "CHE";
+    CHF: "CHF";
+    CHW: "CHW";
+    CLF: "CLF";
+    CLP: "CLP";
+    CNY: "CNY";
+    COP: "COP";
+    COU: "COU";
+    CRC: "CRC";
+    CUC: "CUC";
+    CUP: "CUP";
+    CVE: "CVE";
+    CZK: "CZK";
+    DJF: "DJF";
+    DKK: "DKK";
+    DOP: "DOP";
+    DZD: "DZD";
+    EGP: "EGP";
+    ERN: "ERN";
+    ETB: "ETB";
+    EUR: "EUR";
+    FJD: "FJD";
+    FKP: "FKP";
+    GBP: "GBP";
+    GEL: "GEL";
+    GHS: "GHS";
+    GIP: "GIP";
+    GMD: "GMD";
+    GNF: "GNF";
+    GTQ: "GTQ";
+    GYD: "GYD";
+    HKD: "HKD";
+    HNL: "HNL";
+    HRK: "HRK";
+    HTG: "HTG";
+    HUF: "HUF";
+    IDR: "IDR";
+    ILS: "ILS";
+    INR: "INR";
+    IQD: "IQD";
+    IRR: "IRR";
+    ISK: "ISK";
+    JMD: "JMD";
+    JOD: "JOD";
+    JPY: "JPY";
+    KES: "KES";
+    KGS: "KGS";
+    KHR: "KHR";
+    KMF: "KMF";
+    KPW: "KPW";
+    KRW: "KRW";
+    KWD: "KWD";
+    KYD: "KYD";
+    KZT: "KZT";
+    LAK: "LAK";
+    LBP: "LBP";
+    LKR: "LKR";
+    LRD: "LRD";
+    LSL: "LSL";
+    LYD: "LYD";
+    MAD: "MAD";
+    MDL: "MDL";
+    MGA: "MGA";
+    MKD: "MKD";
+    MMK: "MMK";
+    MNT: "MNT";
+    MOP: "MOP";
+    MRU: "MRU";
+    MUR: "MUR";
+    MVR: "MVR";
+    MWK: "MWK";
+    MXN: "MXN";
+    MXV: "MXV";
+    MYR: "MYR";
+    MZN: "MZN";
+    NAD: "NAD";
+    NGN: "NGN";
+    NIO: "NIO";
+    NOK: "NOK";
+    NPR: "NPR";
+    NZD: "NZD";
+    OMR: "OMR";
+    PAB: "PAB";
+    PEN: "PEN";
+    PGK: "PGK";
+    PHP: "PHP";
+    PKR: "PKR";
+    PLN: "PLN";
+    PYG: "PYG";
+    QAR: "QAR";
+    RON: "RON";
+    RSD: "RSD";
+    RUB: "RUB";
+    RWF: "RWF";
+    SAR: "SAR";
+    SBD: "SBD";
+    SCR: "SCR";
+    SDG: "SDG";
+    SEK: "SEK";
+    SGD: "SGD";
+    SHP: "SHP";
+    SLE: "SLE";
+    SLL: "SLL";
+    SOS: "SOS";
+    SRD: "SRD";
+    SSP: "SSP";
+    STN: "STN";
+    SYP: "SYP";
+    SZL: "SZL";
+    THB: "THB";
+    TJS: "TJS";
+    TMT: "TMT";
+    TND: "TND";
+    TOP: "TOP";
+    TRY: "TRY";
+    TTD: "TTD";
+    TVD: "TVD";
+    TWD: "TWD";
+    TZS: "TZS";
+    UAH: "UAH";
+    UGX: "UGX";
+    USD: "USD";
+    USN: "USN";
+    UYI: "UYI";
+    UYU: "UYU";
+    UYW: "UYW";
+    UZS: "UZS";
+    VED: "VED";
+    VES: "VES";
+    VND: "VND";
+    VUV: "VUV";
+    WST: "WST";
+    XAF: "XAF";
+    XAG: "XAG";
+    XAU: "XAU";
+    XBA: "XBA";
+    XBB: "XBB";
+    XBC: "XBC";
+    XBD: "XBD";
+    XCD: "XCD";
+    XDR: "XDR";
+    XOF: "XOF";
+    XPD: "XPD";
+    XPF: "XPF";
+    XPT: "XPT";
+    XSU: "XSU";
+    XTS: "XTS";
+    XUA: "XUA";
+    XXX: "XXX";
+    YER: "YER";
+    ZAR: "ZAR";
+    ZMW: "ZMW";
+    ZWL: "ZWL";
+}>;
+export type Currency = z.infer<typeof CurrencySchema>;

package/src/schemas/models/identifiers.model.d.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+export declare const FacetIdentifierSchema: z.ZodInterface<{
+    key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const FacetValueIdentifierSchema: z.ZodInterface<{
+    facet: z.ZodDefault<z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+    key: z.ZodDefault<z.ZodString>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const SKUIdentifierSchema: z.ZodInterface<{
+    key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const ProductIdentifierSchema: z.ZodInterface<{
+    key: z.ZodDefault<z.ZodString>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const SearchIdentifierSchema: z.ZodInterface<{
+    term: z.ZodDefault<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    facets: z.ZodDefault<z.ZodArray<z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        facet: z.ZodNonOptional<z.ZodDefault<z.ZodInterface<{
+            key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const CartIdentifierSchema: z.ZodInterface<{
+    key: z.ZodDefault<z.ZodString>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const CartItemIdentifierSchema: z.ZodInterface<{
+    key: z.ZodDefault<z.ZodString>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export declare const PriceIdentifierSchema: z.ZodInterface<{
+    sku: z.ZodDefault<z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type ProductIdentifier = z.infer<typeof ProductIdentifierSchema>;
+export type SearchIdentifier = z.infer<typeof SearchIdentifierSchema>;
+export type FacetIdentifier = z.infer<typeof FacetIdentifierSchema>;
+export type FacetValueIdentifier = z.infer<typeof FacetValueIdentifierSchema>;
+export type CartIdentifier = z.infer<typeof CartIdentifierSchema>;
+export type CartItemIdentifier = z.infer<typeof CartItemIdentifierSchema>;
+export type PriceIdentifier = z.infer<typeof PriceIdentifierSchema>;

package/src/schemas/models/identity.model.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const IdentityTypeSchema: z.ZodEnum<{
+    Anonymous: "Anonymous";
+    Guest: "Guest";
+    Registered: "Registered";
+}>;
+export declare const IdentitySchema: z.MergeInterfaces<z.ZodInterface<{
+    meta: z.ZodDefault<z.ZodInterface<{
+        cache: z.ZodDefault<z.ZodInterface<{
+            hit: z.ZodDefault<z.ZodBoolean>;
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        placeholder: z.ZodDefault<z.ZodBoolean>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    id: z.ZodDefault<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<{
+        Anonymous: "Anonymous";
+        Guest: "Guest";
+        Registered: "Registered";
+    }>>;
+    token: z.ZodOptional<z.ZodString>;
+    issued: z.ZodDefault<z.coerce.ZodCoercedDate>;
+    expiry: z.ZodDefault<z.coerce.ZodCoercedDate>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export type IdentityType = z.infer<typeof IdentityTypeSchema>;
+export type Identity = z.infer<typeof IdentitySchema>;

package/src/schemas/models/inventory.model.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const InventorySchema: z.MergeInterfaces<z.ZodInterface<{
+    meta: z.ZodDefault<z.ZodInterface<{
+        cache: z.ZodDefault<z.ZodInterface<{
+            hit: z.ZodDefault<z.ZodBoolean>;
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        placeholder: z.ZodDefault<z.ZodBoolean>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    quantity: z.ZodDefault<z.ZodNumber>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export type Inventory = z.infer<typeof InventorySchema>;