@schafevormfenster/rest-commons 0.1.1

package/dist/api-schemas/health.schema.d.ts

@@ -0,0 +1,497 @@
+import { z } from "zod";
+/**
+ * Services
+ */
+export declare const ServiceInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    version?: string | undefined;
+}, {
+    name: string;
+    version?: string | undefined;
+}>;
+export type ServiceInfo = z.infer<typeof ServiceInfoSchema>;
+export declare const HealthyServiceInfoSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+} & {
+    message: z.ZodLiteral<"healthy">;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    message: "healthy";
+    name: string;
+    version?: string | undefined;
+}, {
+    status: number;
+    message: "healthy";
+    name: string;
+    version?: string | undefined;
+}>;
+export type HealthyServiceInfo = z.infer<typeof HealthyServiceInfoSchema>;
+export declare const UnhealthyServiceInfoSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    error: z.ZodString;
+    trace: z.ZodOptional<z.ZodAny>;
+} & {
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    error: string;
+    name: string;
+    trace?: any;
+    version?: string | undefined;
+}, {
+    status: number;
+    error: string;
+    name: string;
+    trace?: any;
+    version?: string | undefined;
+}>;
+export type UnhealthyServiceInfo = z.infer<typeof UnhealthyServiceInfoSchema>;
+export declare const ServiceStatusSchema: z.ZodUnion<[z.ZodObject<{
+    status: z.ZodNumber;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+} & {
+    message: z.ZodLiteral<"healthy">;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    message: "healthy";
+    name: string;
+    version?: string | undefined;
+}, {
+    status: number;
+    message: "healthy";
+    name: string;
+    version?: string | undefined;
+}>, z.ZodObject<{
+    status: z.ZodNumber;
+    error: z.ZodString;
+    trace: z.ZodOptional<z.ZodAny>;
+} & {
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    error: string;
+    name: string;
+    trace?: any;
+    version?: string | undefined;
+}, {
+    status: number;
+    error: string;
+    name: string;
+    trace?: any;
+    version?: string | undefined;
+}>]>;
+export type ServiceStatus = z.infer<typeof ServiceStatusSchema>;
+/**
+ * API
+ */
+export declare const ApiInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    services: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        status: z.ZodNumber;
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    } & {
+        message: z.ZodLiteral<"healthy">;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }>, z.ZodObject<{
+        status: z.ZodNumber;
+        error: z.ZodString;
+        trace: z.ZodOptional<z.ZodAny>;
+    } & {
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    description?: string | undefined;
+}, {
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    description?: string | undefined;
+}>;
+export type ApiInfo = z.infer<typeof ApiInfoSchema>;
+export declare const HealthyApiStatusSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+} & {
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    services: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        status: z.ZodNumber;
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    } & {
+        message: z.ZodLiteral<"healthy">;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }>, z.ZodObject<{
+        status: z.ZodNumber;
+        error: z.ZodString;
+        trace: z.ZodOptional<z.ZodAny>;
+    } & {
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    message?: string | undefined;
+    description?: string | undefined;
+}, {
+    status: number;
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    message?: string | undefined;
+    description?: string | undefined;
+}>;
+export type HealthyApiStatus = z.infer<typeof HealthyApiStatusSchema>;
+export declare const UnhealthyApiStatusSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    error: z.ZodString;
+    trace: z.ZodOptional<z.ZodAny>;
+} & {
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    services: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        status: z.ZodNumber;
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    } & {
+        message: z.ZodLiteral<"healthy">;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }>, z.ZodObject<{
+        status: z.ZodNumber;
+        error: z.ZodString;
+        trace: z.ZodOptional<z.ZodAny>;
+    } & {
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    error: string;
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    trace?: any;
+    description?: string | undefined;
+}, {
+    status: number;
+    error: string;
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    trace?: any;
+    description?: string | undefined;
+}>;
+export type UnhealthyApiStatus = z.infer<typeof UnhealthyApiStatusSchema>;
+export declare const ApiStatusSchema: z.ZodUnion<[z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+} & {
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    services: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        status: z.ZodNumber;
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    } & {
+        message: z.ZodLiteral<"healthy">;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }>, z.ZodObject<{
+        status: z.ZodNumber;
+        error: z.ZodString;
+        trace: z.ZodOptional<z.ZodAny>;
+    } & {
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    message?: string | undefined;
+    description?: string | undefined;
+}, {
+    status: number;
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    message?: string | undefined;
+    description?: string | undefined;
+}>, z.ZodObject<{
+    status: z.ZodNumber;
+    error: z.ZodString;
+    trace: z.ZodOptional<z.ZodAny>;
+} & {
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    services: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        status: z.ZodNumber;
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    } & {
+        message: z.ZodLiteral<"healthy">;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }, {
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    }>, z.ZodObject<{
+        status: z.ZodNumber;
+        error: z.ZodString;
+        trace: z.ZodOptional<z.ZodAny>;
+    } & {
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }, {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    error: string;
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    trace?: any;
+    description?: string | undefined;
+}, {
+    status: number;
+    error: string;
+    name: string;
+    version: string;
+    services: ({
+        status: number;
+        message: "healthy";
+        name: string;
+        version?: string | undefined;
+    } | {
+        status: number;
+        error: string;
+        name: string;
+        trace?: any;
+        version?: string | undefined;
+    })[];
+    trace?: any;
+    description?: string | undefined;
+}>]>;
+export type ApiStatus = z.infer<typeof ApiStatusSchema>;
+//# sourceMappingURL=health.schema.d.ts.map

package/dist/api-schemas/health.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.schema.d.ts","sourceRoot":"","sources":["../../src/api-schemas/health.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;EAGnB,CAAC;AAEZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;EAInC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;EACE,CAAC;AAE1C,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CACxC,OAAO,0BAA0B,CAClC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKf,CAAC;AAEZ,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkC,CAAC;AACtE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAsC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/api-schemas/health.schema.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { ApiErrorSchema } from "./error.schema";
+import { OkaySchema } from "./okay.schema";
+/**
+ * Services
+ */
+export const ServiceInfoSchema = z.object({
+    name: z.string(),
+    version: z.string().optional(),
+}).strict();
+export const HealthyServiceInfoSchema = OkaySchema.merge(ServiceInfoSchema).extend({
+    message: z.literal("healthy"),
+});
+export const UnhealthyServiceInfoSchema = ApiErrorSchema.merge(ServiceInfoSchema);
+export const ServiceStatusSchema = z.union([
+    HealthyServiceInfoSchema,
+    UnhealthyServiceInfoSchema,
+]);
+/**
+ * API
+ */
+export const ApiInfoSchema = z.object({
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    services: ServiceStatusSchema.array(),
+}).strict();
+export const HealthyApiStatusSchema = OkaySchema.merge(ApiInfoSchema);
+export const UnhealthyApiStatusSchema = ApiErrorSchema.merge(ApiInfoSchema);
+export const ApiStatusSchema = z.union([
+    HealthyApiStatusSchema,
+    UnhealthyApiStatusSchema,
+]);

package/dist/api-schemas/okay.schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const OkaySchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    message?: string | undefined;
+}, {
+    status: number;
+    message?: string | undefined;
+}>;
+export type Okay = z.infer<typeof OkaySchema>;
+//# sourceMappingURL=okay.schema.d.ts.map

package/dist/api-schemas/okay.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"okay.schema.d.ts","sourceRoot":"","sources":["../../src/api-schemas/okay.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;;;;EAGZ,CAAC;AAEZ,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/api-schemas/okay.schema.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export const OkaySchema = z.object({
+    status: z.number().min(200).max(299),
+    message: z.string().optional(),
+}).strict();

package/dist/api-schemas/paginated-results.schema.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export declare const PaginationSchema: z.ZodObject<{
+    page: z.ZodNumber;
+    limit: z.ZodNumber;
+    totalPages: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    limit: number;
+    totalPages: number;
+}, {
+    page: number;
+    limit: number;
+    totalPages: number;
+}>;
+export type Pagination = z.infer<typeof PaginationSchema>;
+export declare const PaginatedResultsSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+} & {
+    timestamp: z.ZodEffects<z.ZodString, string, string>;
+} & {
+    results: z.ZodNumber;
+} & {
+    pagination: z.ZodObject<{
+        page: z.ZodNumber;
+        limit: z.ZodNumber;
+        totalPages: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        page: number;
+        limit: number;
+        totalPages: number;
+    }, {
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    timestamp: string;
+    results: number;
+    pagination: {
+        page: number;
+        limit: number;
+        totalPages: number;
+    };
+    message?: string | undefined;
+}, {
+    status: number;
+    timestamp: string;
+    results: number;
+    pagination: {
+        page: number;
+        limit: number;
+        totalPages: number;
+    };
+    message?: string | undefined;
+}>;
+export type PaginatedResults = z.infer<typeof PaginatedResultsSchema>;
+//# sourceMappingURL=paginated-results.schema.d.ts.map

package/dist/api-schemas/paginated-results.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginated-results.schema.d.ts","sourceRoot":"","sources":["../../src/api-schemas/paginated-results.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAIlB,CAAC;AAEZ,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/api-schemas/paginated-results.schema.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { ResultsSchema } from "./results.schema";
+export const PaginationSchema = z.object({
+    page: z.number().describe("Current page number"),
+    limit: z.number().describe("Maximum results per page"),
+    totalPages: z.number().describe("Total number of pages"),
+}).strict();
+export const PaginatedResultsSchema = ResultsSchema.extend({
+    pagination: PaginationSchema,
+});

package/dist/api-schemas/partial-results.schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+/**
+ * Schema for partial success responses where some items succeeded and others failed.
+ * Extends ResultsSchema with an errors count field.
+ * Useful for batch operations that can have mixed results (e.g., 422 responses).
+ */
+export declare const PartialResultsSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+} & {
+    timestamp: z.ZodEffects<z.ZodString, string, string>;
+} & {
+    results: z.ZodNumber;
+} & {
+    errors: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    timestamp: string;
+    results: number;
+    errors: number;
+    message?: string | undefined;
+}, {
+    status: number;
+    timestamp: string;
+    results: number;
+    errors: number;
+    message?: string | undefined;
+}>;
+export type PartialResults = z.infer<typeof PartialResultsSchema>;
+//# sourceMappingURL=partial-results.schema.d.ts.map

package/dist/api-schemas/partial-results.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-results.schema.d.ts","sourceRoot":"","sources":["../../src/api-schemas/partial-results.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;EAE/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/api-schemas/partial-results.schema.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { ResultsSchema } from "./results.schema";
+/**
+ * Schema for partial success responses where some items succeeded and others failed.
+ * Extends ResultsSchema with an errors count field.
+ * Useful for batch operations that can have mixed results (e.g., 422 responses).
+ */
+export const PartialResultsSchema = ResultsSchema.extend({
+    errors: z.number(), // Count of failed items
+});

package/dist/api-schemas/result.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const ResultSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    message: z.ZodOptional<z.ZodString>;
+} & {
+    timestamp: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    status: number;
+    timestamp: string;
+    message?: string | undefined;
+}, {
+    status: number;
+    timestamp: string;
+    message?: string | undefined;
+}>;
+export type Result = z.infer<typeof ResultSchema>;
+//# sourceMappingURL=result.schema.d.ts.map

package/dist/api-schemas/result.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.schema.d.ts","sourceRoot":"","sources":["../../src/api-schemas/result.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;EAEvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}