@reactionary/core 0.0.27

package/src/schemas/mutations/analytics.mutation.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+export declare const AnalyticsMutationSearchEventSchema: z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"search">;
+    search: z.ZodInterface<{
+        term: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        page: z.ZodNonOptional<z.ZodDefault<z.ZodNumber>>;
+        pageSize: z.ZodNonOptional<z.ZodDefault<z.ZodNumber>>;
+        facets: z.ZodNonOptional<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>;
+    }>;
+    products: z.ZodArray<z.ZodInterface<{
+        key: z.ZodDefault<z.ZodString>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const AnalyticsMutationSearchProductClickEventSchema: z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"product-search-click">;
+    search: z.ZodInterface<{
+        term: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        page: z.ZodNonOptional<z.ZodDefault<z.ZodNumber>>;
+        pageSize: z.ZodNonOptional<z.ZodDefault<z.ZodNumber>>;
+        facets: z.ZodNonOptional<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>;
+    }>;
+    product: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    position: z.ZodNumber;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const AnalyticsMutationSchema: z.ZodUnion<readonly [z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"search">;
+    search: z.ZodInterface<{
+        term: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        page: z.ZodNonOptional<z.ZodDefault<z.ZodNumber>>;
+        pageSize: z.ZodNonOptional<z.ZodDefault<z.ZodNumber>>;
+        facets: z.ZodNonOptional<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>;
+    }>;
+    products: z.ZodArray<z.ZodInterface<{
+        key: z.ZodDefault<z.ZodString>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>, z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"product-search-click">;
+    search: z.ZodInterface<{
+        term: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+        page: z.ZodNonOptional<z.ZodDefault<z.ZodNumber>>;
+        pageSize: z.ZodNonOptional<z.ZodDefault<z.ZodNumber>>;
+        facets: z.ZodNonOptional<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>;
+    }>;
+    product: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    position: z.ZodNumber;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>]>;
+export type AnalyticsMutation = z.infer<typeof AnalyticsMutationSchema>;
+export type AnalyticsMutationSearchEvent = z.infer<typeof AnalyticsMutationSearchEventSchema>;
+export type AnalyticsMutationSearchProductClickEvent = z.infer<typeof AnalyticsMutationSearchProductClickEventSchema>;

package/src/schemas/mutations/base.mutation.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const BaseMutationSchema: z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type BaseMutation = z.infer<typeof BaseMutationSchema>;

package/src/schemas/mutations/cart.mutation.d.ts

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+export declare const CartMutationItemAddSchema: z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"add">;
+    cart: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    product: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    quantity: z.ZodNumber;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const CartMutationItemRemoveSchema: z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"remove">;
+    cart: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    item: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const CartMutationItemQuantityChangeSchema: z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"adjustQuantity">;
+    cart: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    item: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    quantity: z.ZodNumber;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const CartMutationSchema: z.ZodUnion<readonly [z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"add">;
+    cart: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    product: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    quantity: z.ZodNumber;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>, z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"remove">;
+    cart: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    item: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>, z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"adjustQuantity">;
+    cart: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    item: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+    quantity: z.ZodNumber;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>]>;
+export type CartMutation = z.infer<typeof CartMutationSchema>;
+export type CartMutationItemAdd = z.infer<typeof CartMutationItemAddSchema>;
+export type CartMutationItemRemove = z.infer<typeof CartMutationItemRemoveSchema>;
+export type CartMutationItemQuantityChange = z.infer<typeof CartMutationItemQuantityChangeSchema>;

package/src/schemas/mutations/identity.mutation.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+export declare const IdentityMutationLoginSchema: z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"login">;
+    username: z.ZodString;
+    password: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const IdentityMutationLogoutSchema: z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"logout">;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const IdentityMutationSchema: z.ZodUnion<readonly [z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"login">;
+    username: z.ZodString;
+    password: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>, z.MergeInterfaces<z.ZodInterface<{
+    mutation: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    mutation: z.ZodLiteral<"logout">;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>]>;
+export type IdentityMutation = z.infer<typeof IdentityMutationSchema>;
+export type IdentityMutationLogin = z.infer<typeof IdentityMutationLoginSchema>;
+export type IdentityMutationLogout = z.infer<typeof IdentityMutationLogoutSchema>;

package/src/schemas/mutations/inventory.mutation.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const InventoryMutationSchema: z.ZodUnion<readonly []>;
+export type InventoryMutation = z.infer<typeof InventoryMutationSchema>;

package/src/schemas/mutations/price.mutation.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const PriceMutationSchema: z.ZodUnion<readonly []>;
+export type PriceMutation = z.infer<typeof PriceMutationSchema>;

package/src/schemas/mutations/product.mutation.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const ProductMutationSchema: z.ZodUnion<readonly []>;
+export type ProductMutation = z.infer<typeof ProductMutationSchema>;

package/src/schemas/mutations/search.mutation.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const SearchMutationSchema: z.ZodUnion<readonly []>;
+export type SearchMutation = z.infer<typeof SearchMutationSchema>;

package/src/schemas/queries/analytics.query.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const AnalyticsQuerySchema: z.ZodUnion<readonly []>;
+export type AnalyticsQuery = z.infer<typeof AnalyticsQuerySchema>;

package/src/schemas/queries/base.query.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const BaseQuerySchema: z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type BaseQuery = z.infer<typeof BaseQuerySchema>;

package/src/schemas/queries/cart.query.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const CartQueryByIdSchema: z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"id">;
+    cart: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const CartQuerySchema: z.ZodUnion<readonly [z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"id">;
+    cart: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>]>;
+export type CartQueryById = z.infer<typeof CartQueryByIdSchema>;
+export type CartQuery = z.infer<typeof CartQuerySchema>;

package/src/schemas/queries/identity.query.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const IdentityQuerySelfSchema: z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"self">;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const IdentityQuerySchema: z.ZodUnion<readonly [z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"self">;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>]>;
+export type IdentityQuery = z.infer<typeof IdentityQuerySchema>;
+export type IdentityQuerySelf = z.infer<typeof IdentityQuerySelfSchema>;

package/src/schemas/queries/inventory.query.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const InventoryQuerySchema: z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"sku">;
+    sku: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export type InventoryQuery = z.infer<typeof InventoryQuerySchema>;

package/src/schemas/queries/price.query.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const PriceQueryBySkuSchema: z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"sku">;
+    sku: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodNonOptional<z.ZodDefault<z.ZodString>>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const PriceQuerySchema: z.ZodUnion<readonly [z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"sku">;
+    sku: z.ZodInterface<{
+        key: z.ZodNonOptional<z.ZodNonOptional<z.ZodDefault<z.ZodString>>>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>]>;
+export type PriceQueryBySku = z.infer<typeof PriceQueryBySkuSchema>;
+export type PriceQuery = z.infer<typeof PriceQuerySchema>;

package/src/schemas/queries/product.query.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+export declare const ProductQueryBySlugSchema: z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"slug">;
+    slug: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const ProductQueryByIdSchema: z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"id">;
+    id: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>;
+export declare const ProductQuerySchema: z.ZodUnion<readonly [z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"slug">;
+    slug: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>, z.MergeInterfaces<z.ZodInterface<{
+    query: z.core.$constructor<z.ZodLiteral<z.core.util.Primitive>, z.core.$ZodLiteralDef>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>, z.ZodInterface<{
+    query: z.ZodLiteral<"id">;
+    id: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: {};
+}>>]>;
+export type ProductQueryBySlug = z.infer<typeof ProductQueryBySlugSchema>;
+export type ProductQueryById = z.infer<typeof ProductQueryByIdSchema>;
+export type ProductQuery = z.infer<typeof ProductQuerySchema>;