@teamnovu/kit-shopware-composables 0.0.5 → 0.0.7

package/dist/query/customer/useRegisterCustomerMutation.d.ts

@@ -1,8 +1,9 @@
 import { UseMutationOptions, UseMutationReturnType, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverErrorResult, MutationObserverSuccessResult } from '@tanstack/vue-query';
+import { ShopwareApiError } from '@teamnovu/kit-shopware-api-client';
 import { OperationOptions, OperationResponse } from '../types/query';
 import { components, GenericRecord } from '../../../api-types/storeApiTypes';
 declare const registerOperation = "register post /account/register";
-export declare function useRegisterCustomerMutation(mutationOptions?: UseMutationOptions<OperationResponse<typeof registerOperation>, unknown, OperationOptions<typeof registerOperation>>): UseMutationReturnType<{
+export declare function useRegisterCustomerMutation(mutationOptions?: UseMutationOptions<OperationResponse<typeof registerOperation>, ShopwareApiError | Error, OperationOptions<typeof registerOperation>>): UseMutationReturnType<{
     active?: boolean;
     activeBillingAddress: components["schemas"]["CustomerAddress"];
     activeShippingAddress: components["schemas"]["CustomerAddress"];
@@ -54,7 +55,7 @@ export declare function useRegisterCustomerMutation(mutationOptions?: UseMutatio
     accountType: "business";
     company: string;
     vatIds: [string, ...string[]];
-}), unknown, OperationOptions<"register post /account/register">, unknown, Omit< MutationObserverIdleResult<{
+}), Error | ShopwareApiError, OperationOptions<"register post /account/register">, unknown, Omit< MutationObserverIdleResult<{
     active?: boolean;
     activeBillingAddress: components["schemas"]["CustomerAddress"];
     activeShippingAddress: components["schemas"]["CustomerAddress"];
@@ -106,7 +107,7 @@ export declare function useRegisterCustomerMutation(mutationOptions?: UseMutatio
     accountType: "business";
     company: string;
     vatIds: [string, ...string[]];
-}), unknown, OperationOptions<"register post /account/register">, unknown>, "mutate" | "reset"> | Omit< MutationObserverLoadingResult<{
+}), Error | ShopwareApiError, OperationOptions<"register post /account/register">, unknown>, "mutate" | "reset"> | Omit< MutationObserverLoadingResult<{
     active?: boolean;
     activeBillingAddress: components["schemas"]["CustomerAddress"];
     activeShippingAddress: components["schemas"]["CustomerAddress"];
@@ -158,7 +159,7 @@ export declare function useRegisterCustomerMutation(mutationOptions?: UseMutatio
     accountType: "business";
     company: string;
     vatIds: [string, ...string[]];
-}), unknown, OperationOptions<"register post /account/register">, unknown>, "mutate" | "reset"> | Omit< MutationObserverErrorResult<{
+}), Error | ShopwareApiError, OperationOptions<"register post /account/register">, unknown>, "mutate" | "reset"> | Omit< MutationObserverErrorResult<{
     active?: boolean;
     activeBillingAddress: components["schemas"]["CustomerAddress"];
     activeShippingAddress: components["schemas"]["CustomerAddress"];
@@ -210,7 +211,7 @@ export declare function useRegisterCustomerMutation(mutationOptions?: UseMutatio
     accountType: "business";
     company: string;
     vatIds: [string, ...string[]];
-}), unknown, OperationOptions<"register post /account/register">, unknown>, "mutate" | "reset"> | Omit< MutationObserverSuccessResult<{
+}), Error | ShopwareApiError, OperationOptions<"register post /account/register">, unknown>, "mutate" | "reset"> | Omit< MutationObserverSuccessResult<{
     active?: boolean;
     activeBillingAddress: components["schemas"]["CustomerAddress"];
     activeShippingAddress: components["schemas"]["CustomerAddress"];
@@ -262,5 +263,5 @@ export declare function useRegisterCustomerMutation(mutationOptions?: UseMutatio
     accountType: "business";
     company: string;
     vatIds: [string, ...string[]];
-}), unknown, OperationOptions<"register post /account/register">, unknown>, "mutate" | "reset">>;
+}), Error | ShopwareApiError, OperationOptions<"register post /account/register">, unknown>, "mutate" | "reset">>;
 export {};

package/dist/query/index.d.ts

@@ -2,9 +2,13 @@ export * from './address';
 export * from './cart';
 export * from './checkout';
 export * from './context';
+export * from './country';
 export * from './customer';
+export * from './navigation';
 export * from './order';
 export * from './payment';
 export * from './products';
+export * from './salutation';
+export * from './seoUrl';
 export * from './shipping';
 export * from './types';

package/dist/query/navigation/index.d.ts

@@ -0,0 +1 @@
+export * from './useReadNavigationQuery';

package/dist/query/navigation/useReadNavigationQuery.d.ts

@@ -0,0 +1,22 @@
+import { MaybeRef } from 'vue';
+import { OperationOptions } from '../types/query';
+import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
+declare const readNavigationOperation = "readNavigation post /navigation/{activeId}/{rootId}";
+export declare const useReadNavigationQueryOptions: (activeId: MaybeRef<string>, rootId: MaybeRef<string>, options?: OperationOptions<typeof readNavigationOperation>) => UndefinedInitialQueryOptions<BrandedResponse<Operations, "readNavigation post /navigation/{activeId}/{rootId}">, Error, BrandedResponse<Operations, "readNavigation post /navigation/{activeId}/{rootId}">, readonly ["navigation", "detail", {
+    readonly activeId: MaybeRef<string>;
+    readonly rootId: MaybeRef<string>;
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["navigation", "detail", {
+        readonly activeId: MaybeRef<string>;
+        readonly rootId: MaybeRef<string>;
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: BrandedResponse<Operations, "readNavigation post /navigation/{activeId}/{rootId}">;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function useReadNavigationQuery(activeId: MaybeRef<string>, rootId: MaybeRef<string>, options?: OperationOptions<typeof readNavigationOperation>): UseQueryReturnType<BrandedResponse<Operations, "readNavigation post /navigation/{activeId}/{rootId}">, Error>;
+export {};

package/dist/query/order/useReadOrderQuery.d.ts

@@ -1,44 +1,17 @@
 import { OperationOptions } from '../types/query';
 import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
-import { components } from '../../../api-types/storeApiTypes';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
 declare const readOrderOperation = "readOrder post /order";
-export declare function useReadOrderQueryOptions(options?: OperationOptions<typeof readOrderOperation>): UndefinedInitialQueryOptions<{
-    orders: {
-        elements: components["schemas"]["Order"][];
-    } & components["schemas"]["EntitySearchResult"];
-    paymentChangeable?: {
-        [key: string]: boolean;
-    };
-}, Error, {
-    orders: {
-        elements: components["schemas"]["Order"][];
-    } & components["schemas"]["EntitySearchResult"];
-    paymentChangeable?: {
-        [key: string]: boolean;
-    };
-}, readonly ["order", "detail", {
+export declare function useReadOrderQueryOptions(options?: OperationOptions<typeof readOrderOperation>): UndefinedInitialQueryOptions<BrandedResponse<Operations, "readOrder post /order">, Error, BrandedResponse<Operations, "readOrder post /order">, readonly ["order", "detail", {
     readonly body: unknown;
 }]> & {
     queryKey: readonly ["order", "detail", {
         readonly body: unknown;
     }] & {
-        [dataTagSymbol]: {
-            orders: {
-                elements: components["schemas"]["Order"][];
-            } & components["schemas"]["EntitySearchResult"];
-            paymentChangeable?: {
-                [key: string]: boolean;
-            };
-        };
+        [dataTagSymbol]: BrandedResponse<Operations, "readOrder post /order">;
         [dataTagErrorSymbol]: Error;
     };
 };
-export declare function useReadOrderQuery(options?: OperationOptions<typeof readOrderOperation>): UseQueryReturnType<{
-    orders: {
-        elements: components["schemas"]["Order"][];
-    } & components["schemas"]["EntitySearchResult"];
-    paymentChangeable?: {
-        [key: string]: boolean;
-    };
-}, Error>;
+export declare function useReadOrderQuery(options?: OperationOptions<typeof readOrderOperation>): UseQueryReturnType<BrandedResponse<Operations, "readOrder post /order">, Error>;
 export {};

package/dist/query/payment/useHandlePaymentMutation.d.ts

@@ -1,15 +1,16 @@
+import { ShopwareApiError } from '@teamnovu/kit-shopware-api-client';
 import { UseMutationOptions, UseMutationReturnType, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverErrorResult, MutationObserverSuccessResult } from '@tanstack/vue-query';
 import { OperationOptions, OperationResponse } from '../types/query';
 declare const handlePaymentOperation = "handlePaymentMethod post /handle-payment";
-export declare function useHandlePaymentMutation(mutationOptions?: UseMutationOptions<OperationResponse<typeof handlePaymentOperation>, unknown, OperationOptions<typeof handlePaymentOperation>>): UseMutationReturnType<{
+export declare function useHandlePaymentMutation(mutationOptions?: UseMutationOptions<OperationResponse<typeof handlePaymentOperation>, ShopwareApiError | Error, OperationOptions<typeof handlePaymentOperation>>): UseMutationReturnType<{
     redirectUrl: string;
-}, unknown, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown, Omit< MutationObserverIdleResult<{
+}, Error | ShopwareApiError, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown, Omit< MutationObserverIdleResult<{
     redirectUrl: string;
-}, unknown, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverLoadingResult<{
+}, Error | ShopwareApiError, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverLoadingResult<{
     redirectUrl: string;
-}, unknown, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverErrorResult<{
+}, Error | ShopwareApiError, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverErrorResult<{
     redirectUrl: string;
-}, unknown, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverSuccessResult<{
+}, Error | ShopwareApiError, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverSuccessResult<{
     redirectUrl: string;
-}, unknown, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown>, "mutate" | "reset">>;
+}, Error | ShopwareApiError, OperationOptions<"handlePaymentMethod post /handle-payment">, unknown>, "mutate" | "reset">>;
 export {};

package/dist/query/payment/useOrderSetPaymentMutation.d.ts

@@ -1,15 +1,16 @@
+import { ShopwareApiError } from '@teamnovu/kit-shopware-api-client';
 import { UseMutationOptions, UseMutationReturnType, MutationObserverIdleResult, MutationObserverLoadingResult, MutationObserverErrorResult, MutationObserverSuccessResult } from '@tanstack/vue-query';
 import { OperationOptions, OperationResponse } from '../types/query';
 declare const orderSetPaymentOperation = "orderSetPayment post /order/payment";
-export declare function useOrderSetPaymentMutation(mutationOptions?: UseMutationOptions<OperationResponse<typeof orderSetPaymentOperation>, unknown, OperationOptions<typeof orderSetPaymentOperation>>): UseMutationReturnType<{
+export declare function useOrderSetPaymentMutation(mutationOptions?: UseMutationOptions<OperationResponse<typeof orderSetPaymentOperation>, ShopwareApiError | Error, OperationOptions<typeof orderSetPaymentOperation>>): UseMutationReturnType<{
     success?: boolean;
-}, unknown, OperationOptions<"orderSetPayment post /order/payment">, unknown, Omit< MutationObserverIdleResult<{
+}, Error | ShopwareApiError, OperationOptions<"orderSetPayment post /order/payment">, unknown, Omit< MutationObserverIdleResult<{
     success?: boolean;
-}, unknown, OperationOptions<"orderSetPayment post /order/payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverLoadingResult<{
+}, Error | ShopwareApiError, OperationOptions<"orderSetPayment post /order/payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverLoadingResult<{
     success?: boolean;
-}, unknown, OperationOptions<"orderSetPayment post /order/payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverErrorResult<{
+}, Error | ShopwareApiError, OperationOptions<"orderSetPayment post /order/payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverErrorResult<{
     success?: boolean;
-}, unknown, OperationOptions<"orderSetPayment post /order/payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverSuccessResult<{
+}, Error | ShopwareApiError, OperationOptions<"orderSetPayment post /order/payment">, unknown>, "mutate" | "reset"> | Omit< MutationObserverSuccessResult<{
     success?: boolean;
-}, unknown, OperationOptions<"orderSetPayment post /order/payment">, unknown>, "mutate" | "reset">>;
+}, Error | ShopwareApiError, OperationOptions<"orderSetPayment post /order/payment">, unknown>, "mutate" | "reset">>;
 export {};

package/dist/query/payment/useReadPaymentMethodQuery.d.ts

@@ -1,31 +1,16 @@
 import { OperationOptions } from '../types/query';
 import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
-import { GenericRecord, components } from '../../../api-types/storeApiTypes';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
 export declare const readPaymentMethodOperation = "readPaymentMethod post /payment-method";
-export declare function useReadPaymentMethodQueryOptions(options?: OperationOptions<typeof readPaymentMethodOperation>): UndefinedInitialQueryOptions<{
-    aggregations?: GenericRecord;
-    elements?: components["schemas"]["PaymentMethod"][];
-    total?: number;
-}, Error, {
-    aggregations?: GenericRecord;
-    elements?: components["schemas"]["PaymentMethod"][];
-    total?: number;
-}, readonly ["paymentMethod", "list", {
+export declare function useReadPaymentMethodQueryOptions(options?: OperationOptions<typeof readPaymentMethodOperation>): UndefinedInitialQueryOptions<BrandedResponse<Operations, "readPaymentMethod post /payment-method">, Error, BrandedResponse<Operations, "readPaymentMethod post /payment-method">, readonly ["paymentMethod", "list", {
     readonly body: unknown;
 }]> & {
     queryKey: readonly ["paymentMethod", "list", {
         readonly body: unknown;
     }] & {
-        [dataTagSymbol]: {
-            aggregations?: GenericRecord;
-            elements?: components["schemas"]["PaymentMethod"][];
-            total?: number;
-        };
+        [dataTagSymbol]: BrandedResponse<Operations, "readPaymentMethod post /payment-method">;
         [dataTagErrorSymbol]: Error;
     };
 };
-export declare function useReadPaymentMethodQuery(options?: OperationOptions<typeof readPaymentMethodOperation>): UseQueryReturnType<{
-    aggregations?: GenericRecord;
-    elements?: components["schemas"]["PaymentMethod"][];
-    total?: number;
-}, Error>;
+export declare function useReadPaymentMethodQuery(options?: OperationOptions<typeof readPaymentMethodOperation>): UseQueryReturnType<BrandedResponse<Operations, "readPaymentMethod post /payment-method">, Error>;

package/dist/query/products/useReadCategoryListQuery.d.ts

@@ -1,48 +1,17 @@
 import { OperationOptions } from '../types/query';
 import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
-import { components, GenericRecord } from '../../../api-types/storeApiTypes';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
 declare const readCategoryListOperation = "readCategoryList post /category";
-export declare const useReadCategoryListQueryOptions: (options?: OperationOptions<typeof readCategoryListOperation>) => UndefinedInitialQueryOptions<{
-    elements?: components["schemas"]["Category"][];
-} & {
-    aggregations?: GenericRecord[];
-    entity?: string;
-    limit?: number;
-    page?: number;
-    total?: number;
-}, Error, {
-    elements?: components["schemas"]["Category"][];
-} & {
-    aggregations?: GenericRecord[];
-    entity?: string;
-    limit?: number;
-    page?: number;
-    total?: number;
-}, readonly ["category", "list", {
+export declare const useReadCategoryListQueryOptions: (options?: OperationOptions<typeof readCategoryListOperation>) => UndefinedInitialQueryOptions<BrandedResponse<Operations, "readCategoryList post /category">, Error, BrandedResponse<Operations, "readCategoryList post /category">, readonly ["category", "list", {
     readonly body: unknown;
 }]> & {
     queryKey: readonly ["category", "list", {
         readonly body: unknown;
     }] & {
-        [dataTagSymbol]: {
-            elements?: components["schemas"]["Category"][];
-        } & {
-            aggregations?: GenericRecord[];
-            entity?: string;
-            limit?: number;
-            page?: number;
-            total?: number;
-        };
+        [dataTagSymbol]: BrandedResponse<Operations, "readCategoryList post /category">;
         [dataTagErrorSymbol]: Error;
     };
 };
-export declare function useReadCategoryListQuery(options?: OperationOptions<typeof readCategoryListOperation>): UseQueryReturnType<{
-    elements?: components["schemas"]["Category"][];
-} & {
-    aggregations?: GenericRecord[];
-    entity?: string;
-    limit?: number;
-    page?: number;
-    total?: number;
-}, Error>;
+export declare function useReadCategoryListQuery(options?: OperationOptions<typeof readCategoryListOperation>): UseQueryReturnType<BrandedResponse<Operations, "readCategoryList post /category">, Error>;
 export {};

package/dist/query/products/useReadCompactProductListingQuery.d.ts

@@ -1,17 +1,10 @@
 import { MaybeRef } from 'vue';
 import { OperationOptions } from '../types/query';
 import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
-import { components } from '../../../api-types/storeApiTypes';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
 declare const readListingOperation = "readCompactProductListing post /novu/headless/product-listing/{seoUrl}";
-export declare function useReadCompactProductListingQueryOptions(seoUrl: MaybeRef<string>, options?: OperationOptions<typeof readListingOperation, 'params'>): UndefinedInitialQueryOptions<{
-    apiAlias: "novuProductListing";
-    category: components["schemas"]["Category"];
-    listing: components["schemas"]["ProductListingResult"];
-}, Error, {
-    apiAlias: "novuProductListing";
-    category: components["schemas"]["Category"];
-    listing: components["schemas"]["ProductListingResult"];
-}, readonly ["product", "list", {
+export declare function useReadCompactProductListingQueryOptions(seoUrl: MaybeRef<string>, options?: OperationOptions<typeof readListingOperation, 'params'>): UndefinedInitialQueryOptions<BrandedResponse<Operations, "readCompactProductListing post /novu/headless/product-listing/{seoUrl}">, Error, BrandedResponse<Operations, "readCompactProductListing post /novu/headless/product-listing/{seoUrl}">, readonly ["product", "list", {
     readonly url: MaybeRef<string>;
     readonly body: unknown;
 }]> & {
@@ -19,17 +12,9 @@ export declare function useReadCompactProductListingQueryOptions(seoUrl: MaybeRe
         readonly url: MaybeRef<string>;
         readonly body: unknown;
     }] & {
-        [dataTagSymbol]: {
-            apiAlias: "novuProductListing";
-            category: components["schemas"]["Category"];
-            listing: components["schemas"]["ProductListingResult"];
-        };
+        [dataTagSymbol]: BrandedResponse<Operations, "readCompactProductListing post /novu/headless/product-listing/{seoUrl}">;
         [dataTagErrorSymbol]: Error;
     };
 };
-export declare function useReadCompactProductListingQuery(seoUrl: MaybeRef<string>, options?: OperationOptions<typeof readListingOperation, 'params'>): UseQueryReturnType<{
-    apiAlias: "novuProductListing";
-    category: components["schemas"]["Category"];
-    listing: components["schemas"]["ProductListingResult"];
-}, Error>;
+export declare function useReadCompactProductListingQuery(seoUrl: MaybeRef<string>, options?: OperationOptions<typeof readListingOperation, 'params'>): UseQueryReturnType<BrandedResponse<Operations, "readCompactProductListing post /novu/headless/product-listing/{seoUrl}">, Error>;
 export {};

package/dist/query/products/useReadCustomProductDetailQuery.d.ts

@@ -1,33 +1,10 @@
 import { MaybeRef } from 'vue';
 import { OperationOptions } from '../types/query';
 import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
-import { components, GenericRecord } from '../../../api-types/storeApiTypes';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
 declare const readCustomProductDetailOperation = "readCustomProductDetail post /novu/headless/product/{seoUrl}";
-export declare function useReadCustomProductDetailOptions(seoUrl: MaybeRef<string>, body?: OperationOptions<typeof readCustomProductDetailOperation, 'params'>): UndefinedInitialQueryOptions<{
-    apiAlias: "product_detail";
-    configurator: components["schemas"]["PropertyGroup"][];
-    cross_sellings: components["schemas"]["CrossSellingElementCollection"];
-    custom_fields: GenericRecord;
-    product: components["schemas"]["Product"] & {
-        extensions?: {
-            novuSeoUrls?: GenericRecord;
-            search?: GenericRecord;
-            variants?: components["schemas"]["Product"][];
-        };
-    };
-}, Error, {
-    apiAlias: "product_detail";
-    configurator: components["schemas"]["PropertyGroup"][];
-    cross_sellings: components["schemas"]["CrossSellingElementCollection"];
-    custom_fields: GenericRecord;
-    product: components["schemas"]["Product"] & {
-        extensions?: {
-            novuSeoUrls?: GenericRecord;
-            search?: GenericRecord;
-            variants?: components["schemas"]["Product"][];
-        };
-    };
-}, readonly ["product", "detail", {
+export declare function useReadCustomProductDetailOptions(seoUrl: MaybeRef<string>, body?: OperationOptions<typeof readCustomProductDetailOperation, 'params'>): UndefinedInitialQueryOptions<BrandedResponse<Operations, "readCustomProductDetail post /novu/headless/product/{seoUrl}">, Error, BrandedResponse<Operations, "readCustomProductDetail post /novu/headless/product/{seoUrl}">, readonly ["product", "detail", {
     readonly url: MaybeRef<string>;
     readonly body: unknown;
 }]> & {
@@ -35,33 +12,9 @@ export declare function useReadCustomProductDetailOptions(seoUrl: MaybeRef<strin
         readonly url: MaybeRef<string>;
         readonly body: unknown;
     }] & {
-        [dataTagSymbol]: {
-            apiAlias: "product_detail";
-            configurator: components["schemas"]["PropertyGroup"][];
-            cross_sellings: components["schemas"]["CrossSellingElementCollection"];
-            custom_fields: GenericRecord;
-            product: components["schemas"]["Product"] & {
-                extensions?: {
-                    novuSeoUrls?: GenericRecord;
-                    search?: GenericRecord;
-                    variants?: components["schemas"]["Product"][];
-                };
-            };
-        };
+        [dataTagSymbol]: BrandedResponse<Operations, "readCustomProductDetail post /novu/headless/product/{seoUrl}">;
         [dataTagErrorSymbol]: Error;
     };
 };
-export declare function useReadCustomProductDetailQuery(seoUrl: MaybeRef<string>, body?: OperationOptions<typeof readCustomProductDetailOperation, 'params'>): UseQueryReturnType<{
-    apiAlias: "product_detail";
-    configurator: components["schemas"]["PropertyGroup"][];
-    cross_sellings: components["schemas"]["CrossSellingElementCollection"];
-    custom_fields: GenericRecord;
-    product: components["schemas"]["Product"] & {
-        extensions?: {
-            novuSeoUrls?: GenericRecord;
-            search?: GenericRecord;
-            variants?: components["schemas"]["Product"][];
-        };
-    };
-}, Error>;
+export declare function useReadCustomProductDetailQuery(seoUrl: MaybeRef<string>, body?: OperationOptions<typeof readCustomProductDetailOperation, 'params'>): UseQueryReturnType<BrandedResponse<Operations, "readCustomProductDetail post /novu/headless/product/{seoUrl}">, Error>;
 export {};

package/dist/query/salutation/index.d.ts

@@ -0,0 +1 @@
+export * from './useReadSalutationQuery';

package/dist/query/salutation/useReadSalutationQuery.d.ts

@@ -0,0 +1,17 @@
+import { OperationOptions } from '../types/query';
+import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
+declare const readSalutationOperation = "readSalutation post /salutation";
+export declare const useReadSalutationQueryOptions: (options?: OperationOptions<typeof readSalutationOperation>) => UndefinedInitialQueryOptions<BrandedResponse<Operations, "readSalutation post /salutation">, Error, BrandedResponse<Operations, "readSalutation post /salutation">, readonly ["salutation", "list", {
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["salutation", "list", {
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: BrandedResponse<Operations, "readSalutation post /salutation">;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function useReadSalutationQuery(options?: OperationOptions<typeof readSalutationOperation>): UseQueryReturnType<BrandedResponse<Operations, "readSalutation post /salutation">, Error>;
+export {};

package/dist/query/seoUrl/index.d.ts

@@ -0,0 +1 @@
+export * from './useReadSeoUrlQuery';

package/dist/query/seoUrl/useReadSeoUrlQuery.d.ts

@@ -0,0 +1,17 @@
+import { OperationOptions } from '../types/query';
+import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
+declare const readSeoUrlOperation = "readSeoUrl post /seo-url";
+export declare const useReadSeoUrlQueryOptions: (options?: OperationOptions<typeof readSeoUrlOperation>) => UndefinedInitialQueryOptions<BrandedResponse<Operations, "readSeoUrl post /seo-url">, Error, BrandedResponse<Operations, "readSeoUrl post /seo-url">, readonly ["seoUrl", "list", {
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["seoUrl", "list", {
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: BrandedResponse<Operations, "readSeoUrl post /seo-url">;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function useReadSeoUrlQuery(options?: OperationOptions<typeof readSeoUrlOperation>): UseQueryReturnType<BrandedResponse<Operations, "readSeoUrl post /seo-url">, Error>;
+export {};

package/dist/query/shipping/useReadShippingMethodQuery.d.ts

@@ -1,55 +1,16 @@
 import { OperationOptions } from '../types/query';
 import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
-import { GenericRecord, components } from '../../../api-types/storeApiTypes';
+import { BrandedResponse } from '@teamnovu/kit-shopware-api-client';
+import { Operations } from '..';
 export declare const readShippingMethodOperation = "readShippingMethod post /shipping-method";
-export declare function useReadShippingMethodQueryOptions(options?: OperationOptions<typeof readShippingMethodOperation>): UndefinedInitialQueryOptions<{
-    aggregations?: GenericRecord;
-    elements: components["schemas"]["ShippingMethod"][];
-    total?: number;
-} & {
-    aggregations?: GenericRecord[];
-    entity?: string;
-    limit?: number;
-    page?: number;
-    total?: number;
-}, Error, {
-    aggregations?: GenericRecord;
-    elements: components["schemas"]["ShippingMethod"][];
-    total?: number;
-} & {
-    aggregations?: GenericRecord[];
-    entity?: string;
-    limit?: number;
-    page?: number;
-    total?: number;
-}, readonly ["shippingMethod", "list", {
+export declare function useReadShippingMethodQueryOptions(options?: OperationOptions<typeof readShippingMethodOperation>): UndefinedInitialQueryOptions<BrandedResponse<Operations, "readShippingMethod post /shipping-method">, Error, BrandedResponse<Operations, "readShippingMethod post /shipping-method">, readonly ["shippingMethod", "list", {
     readonly body: unknown;
 }]> & {
     queryKey: readonly ["shippingMethod", "list", {
         readonly body: unknown;
     }] & {
-        [dataTagSymbol]: {
-            aggregations?: GenericRecord;
-            elements: components["schemas"]["ShippingMethod"][];
-            total?: number;
-        } & {
-            aggregations?: GenericRecord[];
-            entity?: string;
-            limit?: number;
-            page?: number;
-            total?: number;
-        };
+        [dataTagSymbol]: BrandedResponse<Operations, "readShippingMethod post /shipping-method">;
         [dataTagErrorSymbol]: Error;
     };
 };
-export declare function useReadShippingMethodQuery(options?: OperationOptions<typeof readShippingMethodOperation>): UseQueryReturnType<{
-    aggregations?: GenericRecord;
-    elements: components["schemas"]["ShippingMethod"][];
-    total?: number;
-} & {
-    aggregations?: GenericRecord[];
-    entity?: string;
-    limit?: number;
-    page?: number;
-    total?: number;
-}, Error>;
+export declare function useReadShippingMethodQuery(options?: OperationOptions<typeof readShippingMethodOperation>): UseQueryReturnType<BrandedResponse<Operations, "readShippingMethod post /shipping-method">, Error>;

package/dist/query/types/index.d.ts

@@ -1,2 +1,3 @@
 export * from './operations';
 export * from './query';
+export * from './util';

package/dist/query/types/operations.d.ts

@@ -1,5 +1,5 @@
-import { operations, Schemas as OriginalSchemas } from '../../../api-types/storeApiTypes.d.ts';
-export interface Operations extends operations {
+import { operations as OriginalOperations, Schemas as OriginalSchemas } from '../../../api-types/storeApiTypes.d.ts';
+export interface Operations extends ShopwareApi.Operations, OriginalOperations {
 }
-export interface Schemas extends OriginalSchemas {
+export interface Schemas extends ShopwareApi.Schemas, OriginalSchemas {
 }

package/dist/query/types/query.d.ts

@@ -1,16 +1,15 @@
-import { operations } from '../../../api-types/storeApiTypes.d.ts';
 import { QueryKey, UseQueryOptions } from '@tanstack/vue-query';
 import { OperationProp, OperationOptions as RawOperationOptions } from '@teamnovu/kit-shopware-api-client';
 import { MaybeRef, UnwrapRef } from 'vue';
 import { Operations } from './operations';
-export type PartialProps<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+import { PartialProps } from './util';
 export type ShallowMaybeRefs<T> = {
     [K in keyof T]: MaybeRef<T[K]>;
 };
 export type ShallowUnwrapRefs<T> = {
     [K in keyof T]: UnwrapRef<T[K]>;
 };
-export type OperationKey = keyof operations;
+export type OperationKey = keyof Operations;
 export type OperationBody<K extends OperationKey> = OperationProp<Operations, K, 'body'>;
 export type OperationResponse<K extends OperationKey> = OperationProp<Operations, K, 'response'>;
 export type OperationOptions<K extends OperationKey, OmitKeys extends keyof RawOperationOptions<Operations, K> = never> = MaybeRef<ShallowMaybeRefs<PartialProps<RawOperationOptions<Operations, K>, OmitKeys>>>;

package/dist/query/types/util.d.ts

@@ -0,0 +1,6 @@
+type DeepOverride<T, U> = {
+    [K in keyof U]: K extends keyof T ? U[K] extends infer UK ? T[K] extends infer TK ? TK extends Record<string, unknown> ? UK extends Record<string, unknown> ? Override<T[K], U[K]> : U[K] : U[K] : U[K] : never : never;
+};
+export type Override<T, U> = T extends Record<string, unknown> ? DeepOverride<T, U> & Omit<T, keyof U> : U;
+export type PartialProps<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export {};

package/dist/util/unrefOptions.d.ts

@@ -1,4 +1,4 @@
 import { OperationOptions as RawOperationOptions } from '@teamnovu/kit-shopware-api-client';
-import { OperationOptions, PartialProps } from '../query/types/query';
-import { Operations } from '../query/types';
+import { OperationOptions } from '../query/types/query';
+import { Operations, PartialProps } from '../query/types';
 export declare function unrefOptions<K extends keyof Operations, OmitKeys extends keyof RawOperationOptions<Operations, K> = never>(options: OperationOptions<K, OmitKeys> | undefined): PartialProps<RawOperationOptions<Operations, K>, OmitKeys>;

package/docs/index.md

@@ -244,7 +244,7 @@ const {
 } = useShippingMethods()
 ```
 
-#### useAddresses
+#### useCheckoutAddresses
 Manage customer addresses:
 
 ```typescript
@@ -255,7 +255,7 @@ const {
   setBillingAddress,
   setShippingAddress,
   isSaving
-} = useAddresses()
+} = useCheckoutAddresses()
 ```
 
 ### Product Helpers
@@ -454,4 +454,4 @@ const handleCheckout = async () => {
   }
 }
 </script>
-```
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamnovu/kit-shopware-composables",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "A collection of composables for the Shopware API",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",
@@ -11,13 +11,13 @@
       "import": "./dist/index.mjs"
     },
     "./operations": {
-      "types": "./dist/types/operations.d.ts"
+      "types": "./dist/global.d.ts"
     }
   },
   "peerDependencies": {
-    "@tanstack/vue-query": "^5.0.0",
+    "@tanstack/vue-query": "^5.75.5",
     "vue": "^3.0.0",
-    "@teamnovu/kit-shopware-api-client": "0.0.3"
+    "@teamnovu/kit-shopware-api-client": "0.0.5"
   },
   "repository": {
     "type": "git",
@@ -32,6 +32,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.25.0",
+    "@microsoft/api-extractor": "^7.52.8",
     "@shopware/api-gen": "^1.3.0",
     "@shopware/helpers": "^1.4.0",
     "@stylistic/eslint-plugin": "^4.2.0",
@@ -42,6 +43,7 @@
     "eslint-import-resolver-typescript": "^4.3.3",
     "eslint-plugin-import": "^2.31.0",
     "typescript-eslint": "^8.30.1",
+    "unplugin-dts": "^1.0.0-beta.4",
     "vitest": "^3.1.2"
   },
   "scripts": {