@simpleapps-com/augur-api 0.3.3 → 0.4.1

package/dist/cjs/services/items/schemas/categoriesImages.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Schema definitions for /categories/{itemCategoryUid}/images endpoint
+ * @fileoverview Type definitions and validation schemas for category images API responses
+ */
+import { z } from 'zod';
+/**
+ * Schema for category image entity
+ */
+export declare const CategoryImageSchema: z.ZodObject<{
+    imageId: z.ZodNumber;
+    imagePath: z.ZodString;
+    imageDesc: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    imagePath: string;
+    imageId: number;
+    sortOrder?: number | undefined;
+    isActive?: boolean | undefined;
+    imageDesc?: string | undefined;
+}, {
+    imagePath: string;
+    imageId: number;
+    sortOrder?: number | undefined;
+    isActive?: boolean | undefined;
+    imageDesc?: string | undefined;
+}>;
+/**
+ * Type definition for category image entity
+ */
+export type CategoryImage = z.infer<typeof CategoryImageSchema>;
+/**
+ * Schema for category images list response
+ */
+export declare const CategoryImagesListResponseSchema: z.ZodEffects<z.ZodObject<{
+    count: z.ZodNumber;
+    data: z.ZodArray<z.ZodObject<{
+        imageId: z.ZodNumber;
+        imagePath: z.ZodString;
+        imageDesc: z.ZodOptional<z.ZodString>;
+        sortOrder: z.ZodOptional<z.ZodNumber>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        imagePath: string;
+        imageId: number;
+        sortOrder?: number | undefined;
+        isActive?: boolean | undefined;
+        imageDesc?: string | undefined;
+    }, {
+        imagePath: string;
+        imageId: number;
+        sortOrder?: number | undefined;
+        isActive?: boolean | undefined;
+        imageDesc?: string | undefined;
+    }>, "many">;
+    message: z.ZodString;
+    options: z.ZodUnion<[z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    params: z.ZodUnion<[z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    status: z.ZodNumber;
+    total: z.ZodNumber;
+    totalResults: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        imagePath: string;
+        imageId: number;
+        sortOrder?: number | undefined;
+        isActive?: boolean | undefined;
+        imageDesc?: string | undefined;
+    }[];
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        imagePath: string;
+        imageId: number;
+        sortOrder?: number | undefined;
+        isActive?: boolean | undefined;
+        imageDesc?: string | undefined;
+    }[];
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}>, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        imagePath: string;
+        imageId: number;
+        sortOrder?: number | undefined;
+        isActive?: boolean | undefined;
+        imageDesc?: string | undefined;
+    }[];
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        imagePath: string;
+        imageId: number;
+        sortOrder?: number | undefined;
+        isActive?: boolean | undefined;
+        imageDesc?: string | undefined;
+    }[];
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}>;
+/**
+ * Type definition for category images list response
+ */
+export type CategoryImagesListResponse = z.infer<typeof CategoryImagesListResponseSchema>;
+//# sourceMappingURL=categoriesImages.d.ts.map

package/dist/cjs/services/items/schemas/categoriesImages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"categoriesImages.d.ts","sourceRoot":"","sources":["../../../../../src/services/items/schemas/categoriesImages.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAmD,CAAC;AAEjG;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/cjs/services/items/schemas/categoriesImages.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Schema definitions for /categories/{itemCategoryUid}/images endpoint
+ * @fileoverview Type definitions and validation schemas for category images API responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CategoryImagesListResponseSchema = exports.CategoryImageSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../core/schemas");
+/**
+ * Schema for category image entity
+ */
+exports.CategoryImageSchema = zod_1.z.object({
+    imageId: zod_1.z.number(),
+    imagePath: zod_1.z.string(),
+    imageDesc: zod_1.z.string().optional(),
+    sortOrder: zod_1.z.number().optional(),
+    isActive: zod_1.z.boolean().optional(),
+});
+/**
+ * Schema for category images list response
+ */
+exports.CategoryImagesListResponseSchema = (0, schemas_1.BaseResponseSchema)(zod_1.z.array(exports.CategoryImageSchema));
+//# sourceMappingURL=categoriesImages.js.map

package/dist/cjs/services/items/schemas/categoriesImages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"categoriesImages.js","sourceRoot":"","sources":["../../../../../src/services/items/schemas/categoriesImages.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,6BAAwB;AACxB,mDAA2D;AAE3D;;GAEG;AACU,QAAA,mBAAmB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC1C,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE;IACnB,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE;IACrB,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,QAAQ,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAOH;;GAEG;AACU,QAAA,gCAAgC,GAAG,IAAA,4BAAkB,EAAC,OAAC,CAAC,KAAK,CAAC,2BAAmB,CAAC,CAAC,CAAC"}

package/dist/cjs/services/items/schemas/index.d.ts

@@ -14,4 +14,22 @@ export * from './brandItems';
 export * from './productLinks';
 export * from './subparts';
 export * from './bins';
+export * from './locationsBins';
+export * from './invMastLinks';
+export * from './invMastSubParts';
+export * from './itemFavorites';
+export * from './invMastDoc';
+export * from './invMastSimilar';
+export * from './invMastAccessory';
+export * from './invMastSub';
+export * from './internalPdf';
+export * from './invMastAlternateCode';
+export * from './invMastAttributes';
+export * from './invMastAttributesValues';
+export * from './attributeGroupsAttributes';
+export * from './invMastLocationsBins';
+export * from './invMastFaq';
+export * from './itemWishlistHdr';
+export { CreateAttributeValueRequestSchema, UpdateAttributeValueRequestSchema, AttributeValueResponseSchema, AttributeValueListResponseSchema, type CreateAttributeValueRequest, type UpdateAttributeValueRequest, } from './attributesValues';
+export { ItemWishlistLineResponseSchema, type ItemWishlistLine, type ItemWishlistLineResponse, } from './itemWishlistLine';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/services/items/schemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/items/schemas/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/items/schemas/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAG1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAGlC,OAAO,EACL,iCAAiC,EACjC,iCAAiC,EACjC,4BAA4B,EAC5B,gCAAgC,EAChC,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,GACjC,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,8BAA8B,EAC9B,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,GAC9B,MAAM,oBAAoB,CAAC"}

package/dist/cjs/services/items/schemas/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemWishlistLineResponseSchema = exports.AttributeValueListResponseSchema = exports.AttributeValueResponseSchema = exports.UpdateAttributeValueRequestSchema = exports.CreateAttributeValueRequestSchema = void 0;
 // Re-export all schemas and types from split files
 __exportStar(require("./products"), exports);
 __exportStar(require("./categories"), exports);
@@ -31,4 +32,29 @@ __exportStar(require("./brandItems"), exports);
 __exportStar(require("./productLinks"), exports);
 __exportStar(require("./subparts"), exports);
 __exportStar(require("./bins"), exports);
+__exportStar(require("./locationsBins"), exports);
+__exportStar(require("./invMastLinks"), exports);
+__exportStar(require("./invMastSubParts"), exports);
+__exportStar(require("./itemFavorites"), exports);
+__exportStar(require("./invMastDoc"), exports);
+__exportStar(require("./invMastSimilar"), exports);
+__exportStar(require("./invMastAccessory"), exports);
+__exportStar(require("./invMastSub"), exports);
+__exportStar(require("./internalPdf"), exports);
+__exportStar(require("./invMastAlternateCode"), exports);
+__exportStar(require("./invMastAttributes"), exports);
+__exportStar(require("./invMastAttributesValues"), exports);
+// New OpenAPI compliance schemas
+__exportStar(require("./attributeGroupsAttributes"), exports);
+__exportStar(require("./invMastLocationsBins"), exports);
+__exportStar(require("./invMastFaq"), exports);
+__exportStar(require("./itemWishlistHdr"), exports);
+// Import specific non-conflicting schemas from new files
+var attributesValues_1 = require("./attributesValues");
+Object.defineProperty(exports, "CreateAttributeValueRequestSchema", { enumerable: true, get: function () { return attributesValues_1.CreateAttributeValueRequestSchema; } });
+Object.defineProperty(exports, "UpdateAttributeValueRequestSchema", { enumerable: true, get: function () { return attributesValues_1.UpdateAttributeValueRequestSchema; } });
+Object.defineProperty(exports, "AttributeValueResponseSchema", { enumerable: true, get: function () { return attributesValues_1.AttributeValueResponseSchema; } });
+Object.defineProperty(exports, "AttributeValueListResponseSchema", { enumerable: true, get: function () { return attributesValues_1.AttributeValueListResponseSchema; } });
+var itemWishlistLine_1 = require("./itemWishlistLine");
+Object.defineProperty(exports, "ItemWishlistLineResponseSchema", { enumerable: true, get: function () { return itemWishlistLine_1.ItemWishlistLineResponseSchema; } });
 //# sourceMappingURL=index.js.map

package/dist/cjs/services/items/schemas/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/services/items/schemas/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mDAAmD;AACnD,6CAA2B;AAC3B,+CAA6B;AAC7B,+CAA6B;AAC7B,2CAAyB;AACzB,kDAAgC;AAChC,oDAAkC;AAClC,2CAAyB;AACzB,2CAAyB;AACzB,8CAA4B;AAC5B,8CAA4B;AAC5B,6CAA2B;AAC3B,wCAAsB;AACtB,+CAA6B;AAC7B,iDAA+B;AAC/B,6CAA2B;AAC3B,yCAAuB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/services/items/schemas/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,mDAAmD;AACnD,6CAA2B;AAC3B,+CAA6B;AAC7B,+CAA6B;AAC7B,2CAAyB;AACzB,kDAAgC;AAChC,oDAAkC;AAClC,2CAAyB;AACzB,2CAAyB;AACzB,8CAA4B;AAC5B,8CAA4B;AAC5B,6CAA2B;AAC3B,wCAAsB;AACtB,+CAA6B;AAC7B,iDAA+B;AAC/B,6CAA2B;AAC3B,yCAAuB;AACvB,kDAAgC;AAChC,iDAA+B;AAC/B,oDAAkC;AAClC,kDAAgC;AAChC,+CAA6B;AAC7B,mDAAiC;AACjC,qDAAmC;AACnC,+CAA6B;AAC7B,gDAA8B;AAC9B,yDAAuC;AACvC,sDAAoC;AACpC,4DAA0C;AAE1C,iCAAiC;AACjC,8DAA4C;AAC5C,yDAAuC;AACvC,+CAA6B;AAC7B,oDAAkC;AAElC,yDAAyD;AACzD,uDAO4B;AAN1B,qIAAA,iCAAiC,OAAA;AACjC,qIAAA,iCAAiC,OAAA;AACjC,gIAAA,4BAA4B,OAAA;AAC5B,oIAAA,gCAAgC,OAAA;AAKlC,uDAI4B;AAH1B,kIAAA,8BAA8B,OAAA"}

package/dist/cjs/services/items/schemas/internalPdf.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+/**
+ * PDF creation request schema
+ */
+export declare const CreateInternalPdfRequestSchema: z.ZodObject<{
+    documentType: z.ZodString;
+    templateId: z.ZodOptional<z.ZodString>;
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+    options: z.ZodOptional<z.ZodObject<{
+        format: z.ZodOptional<z.ZodEnum<["A4", "letter"]>>;
+        orientation: z.ZodOptional<z.ZodEnum<["portrait", "landscape"]>>;
+        margin: z.ZodOptional<z.ZodObject<{
+            top: z.ZodOptional<z.ZodNumber>;
+            bottom: z.ZodOptional<z.ZodNumber>;
+            left: z.ZodOptional<z.ZodNumber>;
+            right: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            top?: number | undefined;
+            bottom?: number | undefined;
+            left?: number | undefined;
+            right?: number | undefined;
+        }, {
+            top?: number | undefined;
+            bottom?: number | undefined;
+            left?: number | undefined;
+            right?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        format?: "A4" | "letter" | undefined;
+        orientation?: "portrait" | "landscape" | undefined;
+        margin?: {
+            top?: number | undefined;
+            bottom?: number | undefined;
+            left?: number | undefined;
+            right?: number | undefined;
+        } | undefined;
+    }, {
+        format?: "A4" | "letter" | undefined;
+        orientation?: "portrait" | "landscape" | undefined;
+        margin?: {
+            top?: number | undefined;
+            bottom?: number | undefined;
+            left?: number | undefined;
+            right?: number | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    data: Record<string, any>;
+    documentType: string;
+    options?: {
+        format?: "A4" | "letter" | undefined;
+        orientation?: "portrait" | "landscape" | undefined;
+        margin?: {
+            top?: number | undefined;
+            bottom?: number | undefined;
+            left?: number | undefined;
+            right?: number | undefined;
+        } | undefined;
+    } | undefined;
+    templateId?: string | undefined;
+}, {
+    data: Record<string, any>;
+    documentType: string;
+    options?: {
+        format?: "A4" | "letter" | undefined;
+        orientation?: "portrait" | "landscape" | undefined;
+        margin?: {
+            top?: number | undefined;
+            bottom?: number | undefined;
+            left?: number | undefined;
+            right?: number | undefined;
+        } | undefined;
+    } | undefined;
+    templateId?: string | undefined;
+}>;
+export type CreateInternalPdfRequest = z.infer<typeof CreateInternalPdfRequestSchema>;
+/**
+ * PDF response data schema
+ */
+export declare const InternalPdfDataSchema: z.ZodObject<{
+    pdfId: z.ZodString;
+    documentType: z.ZodString;
+    fileName: z.ZodString;
+    fileSize: z.ZodNumber;
+    downloadUrl: z.ZodString;
+    createdAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    documentType: string;
+    pdfId: string;
+    fileName: string;
+    fileSize: number;
+    downloadUrl: string;
+    createdAt: string;
+    expiresAt?: string | undefined;
+}, {
+    documentType: string;
+    pdfId: string;
+    fileName: string;
+    fileSize: number;
+    downloadUrl: string;
+    createdAt: string;
+    expiresAt?: string | undefined;
+}>;
+export type InternalPdfData = z.infer<typeof InternalPdfDataSchema>;
+/**
+ * Response schema for PDF creation
+ */
+export declare const InternalPdfResponseSchema: z.ZodEffects<z.ZodObject<{
+    count: z.ZodNumber;
+    data: z.ZodObject<{
+        pdfId: z.ZodString;
+        documentType: z.ZodString;
+        fileName: z.ZodString;
+        fileSize: z.ZodNumber;
+        downloadUrl: z.ZodString;
+        createdAt: z.ZodString;
+        expiresAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        documentType: string;
+        pdfId: string;
+        fileName: string;
+        fileSize: number;
+        downloadUrl: string;
+        createdAt: string;
+        expiresAt?: string | undefined;
+    }, {
+        documentType: string;
+        pdfId: string;
+        fileName: string;
+        fileSize: number;
+        downloadUrl: string;
+        createdAt: string;
+        expiresAt?: string | undefined;
+    }>;
+    message: z.ZodString;
+    options: z.ZodUnion<[z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    params: z.ZodUnion<[z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    status: z.ZodNumber;
+    total: z.ZodNumber;
+    totalResults: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        documentType: string;
+        pdfId: string;
+        fileName: string;
+        fileSize: number;
+        downloadUrl: string;
+        createdAt: string;
+        expiresAt?: string | undefined;
+    };
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        documentType: string;
+        pdfId: string;
+        fileName: string;
+        fileSize: number;
+        downloadUrl: string;
+        createdAt: string;
+        expiresAt?: string | undefined;
+    };
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}>, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        documentType: string;
+        pdfId: string;
+        fileName: string;
+        fileSize: number;
+        downloadUrl: string;
+        createdAt: string;
+        expiresAt?: string | undefined;
+    };
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        documentType: string;
+        pdfId: string;
+        fileName: string;
+        fileSize: number;
+        downloadUrl: string;
+        createdAt: string;
+        expiresAt?: string | undefined;
+    };
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}>;
+export type InternalPdfResponse = z.infer<typeof InternalPdfResponseSchema>;
+//# sourceMappingURL=internalPdf.d.ts.map

package/dist/cjs/services/items/schemas/internalPdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalPdf.d.ts","sourceRoot":"","sources":["../../../../../src/services/items/schemas/internalPdf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBzC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;EAQhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA4C,CAAC;AAEnF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/cjs/services/items/schemas/internalPdf.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalPdfResponseSchema = exports.InternalPdfDataSchema = exports.CreateInternalPdfRequestSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../core/schemas");
+/**
+ * PDF creation request schema
+ */
+exports.CreateInternalPdfRequestSchema = zod_1.z.object({
+    documentType: zod_1.z.string(),
+    templateId: zod_1.z.string().optional(),
+    data: zod_1.z.record(zod_1.z.any()),
+    options: zod_1.z
+        .object({
+        format: zod_1.z.enum(['A4', 'letter']).optional(),
+        orientation: zod_1.z.enum(['portrait', 'landscape']).optional(),
+        margin: zod_1.z
+            .object({
+            top: zod_1.z.number().optional(),
+            bottom: zod_1.z.number().optional(),
+            left: zod_1.z.number().optional(),
+            right: zod_1.z.number().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+});
+/**
+ * PDF response data schema
+ */
+exports.InternalPdfDataSchema = zod_1.z.object({
+    pdfId: zod_1.z.string(),
+    documentType: zod_1.z.string(),
+    fileName: zod_1.z.string(),
+    fileSize: zod_1.z.number(),
+    downloadUrl: zod_1.z.string(),
+    createdAt: zod_1.z.string(),
+    expiresAt: zod_1.z.string().optional(),
+});
+/**
+ * Response schema for PDF creation
+ */
+exports.InternalPdfResponseSchema = (0, schemas_1.BaseResponseSchema)(exports.InternalPdfDataSchema);
+//# sourceMappingURL=internalPdf.js.map

package/dist/cjs/services/items/schemas/internalPdf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalPdf.js","sourceRoot":"","sources":["../../../../../src/services/items/schemas/internalPdf.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,mDAA2D;AAE3D;;GAEG;AACU,QAAA,8BAA8B,GAAG,OAAC,CAAC,MAAM,CAAC;IACrD,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE;IACxB,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,IAAI,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,GAAG,EAAE,CAAC;IACvB,OAAO,EAAE,OAAC;SACP,MAAM,CAAC;QACN,MAAM,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE;QAC3C,WAAW,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC,QAAQ,EAAE;QACzD,MAAM,EAAE,OAAC;aACN,MAAM,CAAC;YACN,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;YAC1B,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;YAC7B,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;YAC3B,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;SAC7B,CAAC;aACD,QAAQ,EAAE;KACd,CAAC;SACD,QAAQ,EAAE;CACd,CAAC,CAAC;AAIH;;GAEG;AACU,QAAA,qBAAqB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC5C,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE;IACjB,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE;IACxB,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE;IACpB,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE;IACpB,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE;IACvB,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE;IACrB,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAIH;;GAEG;AACU,QAAA,yBAAyB,GAAG,IAAA,4BAAkB,EAAC,6BAAqB,CAAC,CAAC"}

package/dist/cjs/services/items/schemas/invMastAccessory.d.ts

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+/**
+ * Inventory accessory data schema
+ */
+export declare const InvAccessoryDataSchema: z.ZodObject<{
+    invMastUid: z.ZodNumber;
+    accessoryInvMastUid: z.ZodNumber;
+    partNumber: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    accessoryType: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    invMastUid: number;
+    accessoryInvMastUid: number;
+    description?: string | undefined;
+    accessoryType?: string | undefined;
+    partNumber?: string | undefined;
+    required?: boolean | undefined;
+}, {
+    invMastUid: number;
+    accessoryInvMastUid: number;
+    description?: string | undefined;
+    accessoryType?: string | undefined;
+    partNumber?: string | undefined;
+    required?: boolean | undefined;
+}>;
+export type InvAccessoryData = z.infer<typeof InvAccessoryDataSchema>;
+/**
+ * Response schema for inventory accessories
+ */
+export declare const InvAccessoryListResponseSchema: z.ZodEffects<z.ZodObject<{
+    count: z.ZodNumber;
+    data: z.ZodArray<z.ZodObject<{
+        invMastUid: z.ZodNumber;
+        accessoryInvMastUid: z.ZodNumber;
+        partNumber: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        accessoryType: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        invMastUid: number;
+        accessoryInvMastUid: number;
+        description?: string | undefined;
+        accessoryType?: string | undefined;
+        partNumber?: string | undefined;
+        required?: boolean | undefined;
+    }, {
+        invMastUid: number;
+        accessoryInvMastUid: number;
+        description?: string | undefined;
+        accessoryType?: string | undefined;
+        partNumber?: string | undefined;
+        required?: boolean | undefined;
+    }>, "many">;
+    message: z.ZodString;
+    options: z.ZodUnion<[z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    params: z.ZodUnion<[z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    status: z.ZodNumber;
+    total: z.ZodNumber;
+    totalResults: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        invMastUid: number;
+        accessoryInvMastUid: number;
+        description?: string | undefined;
+        accessoryType?: string | undefined;
+        partNumber?: string | undefined;
+        required?: boolean | undefined;
+    }[];
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        invMastUid: number;
+        accessoryInvMastUid: number;
+        description?: string | undefined;
+        accessoryType?: string | undefined;
+        partNumber?: string | undefined;
+        required?: boolean | undefined;
+    }[];
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}>, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        invMastUid: number;
+        accessoryInvMastUid: number;
+        description?: string | undefined;
+        accessoryType?: string | undefined;
+        partNumber?: string | undefined;
+        required?: boolean | undefined;
+    }[];
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        invMastUid: number;
+        accessoryInvMastUid: number;
+        description?: string | undefined;
+        accessoryType?: string | undefined;
+        partNumber?: string | undefined;
+        required?: boolean | undefined;
+    }[];
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}>;
+export type InvAccessoryListResponse = z.infer<typeof InvAccessoryListResponseSchema>;
+//# sourceMappingURL=invMastAccessory.d.ts.map

package/dist/cjs/services/items/schemas/invMastAccessory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invMastAccessory.d.ts","sourceRoot":"","sources":["../../../../../src/services/items/schemas/invMastAccessory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EAOjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAsD,CAAC;AAElG,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}

package/dist/cjs/services/items/schemas/invMastAccessory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvAccessoryListResponseSchema = exports.InvAccessoryDataSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../core/schemas");
+/**
+ * Inventory accessory data schema
+ */
+exports.InvAccessoryDataSchema = zod_1.z.object({
+    invMastUid: zod_1.z.number(),
+    accessoryInvMastUid: zod_1.z.number(),
+    partNumber: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    accessoryType: zod_1.z.string().optional(),
+    required: zod_1.z.boolean().optional(),
+});
+/**
+ * Response schema for inventory accessories
+ */
+exports.InvAccessoryListResponseSchema = (0, schemas_1.BaseResponseSchema)(zod_1.z.array(exports.InvAccessoryDataSchema));
+//# sourceMappingURL=invMastAccessory.js.map

package/dist/cjs/services/items/schemas/invMastAccessory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invMastAccessory.js","sourceRoot":"","sources":["../../../../../src/services/items/schemas/invMastAccessory.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,mDAA2D;AAE3D;;GAEG;AACU,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC7C,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE;IACtB,mBAAmB,EAAE,OAAC,CAAC,MAAM,EAAE;IAC/B,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACpC,QAAQ,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAIH;;GAEG;AACU,QAAA,8BAA8B,GAAG,IAAA,4BAAkB,EAAC,OAAC,CAAC,KAAK,CAAC,8BAAsB,CAAC,CAAC,CAAC"}