@prave/shared 0.1.0

package/dist/schemas/skill-dependency.schema.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { skillSchema } from './skill.schema.js';
+/** A single `skill → depends_on` edge as stored in `skill_dependencies`. */
+export const skillDependencySchema = z.object({
+    skill_id: z.string().uuid(),
+    depends_on_skill_id: z.string().uuid(),
+    version_pin: z.number().int().positive().nullable(),
+    sort_order: z.number().int().nonnegative().default(0),
+    created_at: z.string().datetime(),
+});
+/**
+ * Hydrated dependency row — same as SkillDependency, but with the
+ * target Skill joined in so the UI can render names + slugs without
+ * a second round-trip.
+ */
+export const dependencyRowSchema = skillDependencySchema.extend({
+    target: skillSchema.pick({
+        id: true,
+        slug: true,
+        name: true,
+        description: true,
+        visibility: true,
+    }),
+});
+export const addDependencyInputSchema = z.object({
+    depends_on_slug: z
+        .string()
+        .min(1)
+        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'slug must be kebab-case'),
+    version_pin: z.number().int().positive().nullable().optional(),
+    sort_order: z.number().int().nonnegative().optional(),
+});

package/dist/schemas/skill-test.schema.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+/**
+ * BYOK (Bring Your Own Key) tester input. The API **never** persists
+ * the caller's Anthropic key — it's used once for the round-trip and
+ * dropped. Store hashes of keys only if rate-limiting is added later.
+ */
+export declare const skillTestInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    api_key: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    api_key: string;
+    model?: string | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+}, {
+    prompt: string;
+    api_key: string;
+    model?: string | undefined;
+    max_tokens?: number | undefined;
+    temperature?: number | undefined;
+}>;
+export type SkillTestInput = z.infer<typeof skillTestInputSchema>;
+export declare const skillTestResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    skill_id: z.ZodString;
+    model: z.ZodString;
+    input_prompt: z.ZodString;
+    output: z.ZodString;
+    latency_ms: z.ZodNumber;
+    input_tokens: z.ZodNullable<z.ZodNumber>;
+    output_tokens: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<["pending", "success", "error"]>;
+    error_message: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "success" | "error" | "pending";
+    id: string;
+    created_at: string;
+    skill_id: string;
+    model: string;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    input_prompt: string;
+    output: string;
+    latency_ms: number;
+    error_message: string | null;
+}, {
+    status: "success" | "error" | "pending";
+    id: string;
+    created_at: string;
+    skill_id: string;
+    model: string;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    input_prompt: string;
+    output: string;
+    latency_ms: number;
+    error_message: string | null;
+}>;
+export type SkillTestResult = z.infer<typeof skillTestResultSchema>;
+//# sourceMappingURL=skill-test.schema.d.ts.map

package/dist/schemas/skill-test.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-test.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/skill-test.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAU/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/schemas/skill-test.schema.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+/**
+ * BYOK (Bring Your Own Key) tester input. The API **never** persists
+ * the caller's Anthropic key — it's used once for the round-trip and
+ * dropped. Store hashes of keys only if rate-limiting is added later.
+ */
+export const skillTestInputSchema = z.object({
+    prompt: z.string().min(1).max(12_000),
+    api_key: z
+        .string()
+        .min(10)
+        .max(256)
+        .regex(/^sk-ant-/, 'Must be an Anthropic key (starts with sk-ant-)'),
+    model: z.string().min(1).max(80).optional(),
+    max_tokens: z.number().int().min(1).max(8192).optional(),
+    temperature: z.number().min(0).max(1).optional(),
+});
+export const skillTestResultSchema = z.object({
+    id: z.string().uuid(),
+    skill_id: z.string().uuid(),
+    model: z.string(),
+    input_prompt: z.string(),
+    output: z.string(),
+    latency_ms: z.number().int().nonnegative(),
+    input_tokens: z.number().int().nullable(),
+    output_tokens: z.number().int().nullable(),
+    status: z.enum(['pending', 'success', 'error']),
+    error_message: z.string().nullable(),
+    created_at: z.string().datetime(),
+});

package/dist/schemas/skill-version.schema.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+/**
+ * A snapshot of a Skill's `content` at one point in time. Written
+ * automatically by the API whenever the content changes, plus explicitly
+ * on revert. Monotonic per-skill `version` integer, starting at 1.
+ */
+export declare const skillVersionSchema: z.ZodObject<{
+    id: z.ZodString;
+    skill_id: z.ZodString;
+    version: z.ZodNumber;
+    content: z.ZodString;
+    commit_message: z.ZodNullable<z.ZodString>;
+    created_by: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    content: string;
+    created_at: string;
+    commit_message: string | null;
+    skill_id: string;
+    version: number;
+    created_by: string | null;
+}, {
+    id: string;
+    content: string;
+    created_at: string;
+    commit_message: string | null;
+    skill_id: string;
+    version: number;
+    created_by: string | null;
+}>;
+export type SkillVersion = z.infer<typeof skillVersionSchema>;
+/** Compact list row — omits the full `content` blob so timelines stay cheap. */
+export declare const skillVersionSummarySchema: z.ZodObject<Omit<{
+    id: z.ZodString;
+    skill_id: z.ZodString;
+    version: z.ZodNumber;
+    content: z.ZodString;
+    commit_message: z.ZodNullable<z.ZodString>;
+    created_by: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+}, "content">, "strip", z.ZodTypeAny, {
+    id: string;
+    created_at: string;
+    commit_message: string | null;
+    skill_id: string;
+    version: number;
+    created_by: string | null;
+}, {
+    id: string;
+    created_at: string;
+    commit_message: string | null;
+    skill_id: string;
+    version: number;
+    created_by: string | null;
+}>;
+export type SkillVersionSummary = z.infer<typeof skillVersionSummarySchema>;
+export declare const revertSkillInputSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    commit_message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    commit_message?: string | undefined;
+}, {
+    version: number;
+    commit_message?: string | undefined;
+}>;
+export type RevertSkillInput = z.infer<typeof revertSkillInputSchema>;
+//# sourceMappingURL=skill-version.schema.d.ts.map

package/dist/schemas/skill-version.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-version.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/skill-version.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;EAQ7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,gFAAgF;AAChF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;EAA6C,CAAA;AACnF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/schemas/skill-version.schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+/**
+ * A snapshot of a Skill's `content` at one point in time. Written
+ * automatically by the API whenever the content changes, plus explicitly
+ * on revert. Monotonic per-skill `version` integer, starting at 1.
+ */
+export const skillVersionSchema = z.object({
+    id: z.string().uuid(),
+    skill_id: z.string().uuid(),
+    version: z.number().int().positive(),
+    content: z.string(),
+    commit_message: z.string().nullable(),
+    created_by: z.string().uuid().nullable(),
+    created_at: z.string().datetime(),
+});
+/** Compact list row — omits the full `content` blob so timelines stay cheap. */
+export const skillVersionSummarySchema = skillVersionSchema.omit({ content: true });
+export const revertSkillInputSchema = z.object({
+    version: z.number().int().positive(),
+    commit_message: z.string().max(200).optional(),
+});

package/dist/schemas/skill.schema.d.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+export declare const skillVisibilitySchema: z.ZodEnum<["public", "private", "org"]>;
+export type SkillVisibility = z.infer<typeof skillVisibilitySchema>;
+export declare const skillSchema: z.ZodObject<{
+    id: z.ZodString;
+    owner_id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    content: z.ZodNullable<z.ZodString>;
+    visibility: z.ZodDefault<z.ZodEnum<["public", "private", "org"]>>;
+    source_repo: z.ZodNullable<z.ZodString>;
+    license: z.ZodDefault<z.ZodString>;
+    category: z.ZodNullable<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    install_count: z.ZodDefault<z.ZodNumber>;
+    bookmark_count: z.ZodDefault<z.ZodNumber>;
+    is_verified: z.ZodDefault<z.ZodBoolean>;
+    price_cents: z.ZodDefault<z.ZodNumber>;
+    currency: z.ZodDefault<z.ZodString>;
+    /** Attached by the API on GET: true if the caller has paid for the Skill. */
+    purchased: z.ZodOptional<z.ZodBoolean>;
+    /** Attached by the API on GET: true if the caller is the owner. */
+    is_owner: z.ZodOptional<z.ZodBoolean>;
+    /** Attached by the API on GET: true if the caller has bookmarked the Skill. */
+    bookmarked: z.ZodOptional<z.ZodBoolean>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    owner_id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    content: string | null;
+    visibility: "public" | "private" | "org";
+    source_repo: string | null;
+    license: string;
+    category: string | null;
+    tags: string[];
+    install_count: number;
+    bookmark_count: number;
+    is_verified: boolean;
+    price_cents: number;
+    currency: string;
+    created_at: string;
+    updated_at: string;
+    purchased?: boolean | undefined;
+    is_owner?: boolean | undefined;
+    bookmarked?: boolean | undefined;
+}, {
+    id: string;
+    owner_id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    content: string | null;
+    source_repo: string | null;
+    category: string | null;
+    created_at: string;
+    updated_at: string;
+    visibility?: "public" | "private" | "org" | undefined;
+    license?: string | undefined;
+    tags?: string[] | undefined;
+    install_count?: number | undefined;
+    bookmark_count?: number | undefined;
+    is_verified?: boolean | undefined;
+    price_cents?: number | undefined;
+    currency?: string | undefined;
+    purchased?: boolean | undefined;
+    is_owner?: boolean | undefined;
+    bookmarked?: boolean | undefined;
+}>;
+export type Skill = z.infer<typeof skillSchema>;
+export declare const createSkillInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    visibility: z.ZodOptional<z.ZodDefault<z.ZodEnum<["public", "private", "org"]>>>;
+    source_repo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    license: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    price_cents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    currency: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    slug: string;
+    description?: string | null | undefined;
+    content?: string | null | undefined;
+    visibility?: "public" | "private" | "org" | undefined;
+    source_repo?: string | null | undefined;
+    license?: string | undefined;
+    category?: string | null | undefined;
+    tags?: string[] | undefined;
+    price_cents?: number | undefined;
+    currency?: string | undefined;
+}, {
+    name: string;
+    slug: string;
+    description?: string | null | undefined;
+    content?: string | null | undefined;
+    visibility?: "public" | "private" | "org" | undefined;
+    source_repo?: string | null | undefined;
+    license?: string | undefined;
+    category?: string | null | undefined;
+    tags?: string[] | undefined;
+    price_cents?: number | undefined;
+    currency?: string | undefined;
+}>;
+export type CreateSkillInput = z.infer<typeof createSkillInputSchema>;
+export declare const updateSkillInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    content: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    visibility: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodEnum<["public", "private", "org"]>>>>;
+    source_repo: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    license: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodString>>>;
+    category: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    tags: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>>;
+    price_cents: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodNumber>>>;
+    currency: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodString>>>;
+} & {
+    commit_message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    slug?: string | undefined;
+    description?: string | null | undefined;
+    content?: string | null | undefined;
+    visibility?: "public" | "private" | "org" | undefined;
+    source_repo?: string | null | undefined;
+    license?: string | undefined;
+    category?: string | null | undefined;
+    tags?: string[] | undefined;
+    price_cents?: number | undefined;
+    currency?: string | undefined;
+    commit_message?: string | undefined;
+}, {
+    name?: string | undefined;
+    slug?: string | undefined;
+    description?: string | null | undefined;
+    content?: string | null | undefined;
+    visibility?: "public" | "private" | "org" | undefined;
+    source_repo?: string | null | undefined;
+    license?: string | undefined;
+    category?: string | null | undefined;
+    tags?: string[] | undefined;
+    price_cents?: number | undefined;
+    currency?: string | undefined;
+    commit_message?: string | undefined;
+}>;
+export type UpdateSkillInput = z.infer<typeof updateSkillInputSchema>;
+export declare const skillSortSchema: z.ZodEnum<["trending", "popular", "newest", "relevance"]>;
+export type SkillSort = z.infer<typeof skillSortSchema>;
+export declare const skillSearchQuerySchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    sort: z.ZodDefault<z.ZodEnum<["trending", "popular", "newest", "relevance"]>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sort: "trending" | "popular" | "newest" | "relevance";
+    limit: number;
+    offset: number;
+    category?: string | undefined;
+    q?: string | undefined;
+    tag?: string | undefined;
+}, {
+    sort?: "trending" | "popular" | "newest" | "relevance" | undefined;
+    category?: string | undefined;
+    q?: string | undefined;
+    tag?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type SkillSearchQuery = z.infer<typeof skillSearchQuerySchema>;
+//# sourceMappingURL=skill.schema.d.ts.map

package/dist/schemas/skill.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/skill.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,qBAAqB,yCAAuC,CAAA;AACzE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;IAqBtB,6EAA6E;;IAE7E,mEAAmE;;IAEnE,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI/E,CAAA;AACF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwB/B,CAAA;AACJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,eAAe,2DAAyD,CAAA;AACrF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EAOjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/schemas/skill.schema.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export const skillVisibilitySchema = z.enum(['public', 'private', 'org']);
+export const skillSchema = z.object({
+    id: z.string().uuid(),
+    owner_id: z.string().uuid(),
+    name: z.string().min(1).max(120),
+    slug: z
+        .string()
+        .min(1)
+        .max(120)
+        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'slug must be kebab-case'),
+    description: z.string().max(500).nullable(),
+    content: z.string().nullable(),
+    visibility: skillVisibilitySchema.default('public'),
+    source_repo: z.string().url().nullable(),
+    license: z.string().default('MIT'),
+    category: z.string().nullable(),
+    tags: z.array(z.string()).default([]),
+    install_count: z.number().int().nonnegative().default(0),
+    bookmark_count: z.number().int().nonnegative().default(0),
+    is_verified: z.boolean().default(false),
+    price_cents: z.number().int().nonnegative().default(0),
+    currency: z.string().default('EUR'),
+    /** Attached by the API on GET: true if the caller has paid for the Skill. */
+    purchased: z.boolean().optional(),
+    /** Attached by the API on GET: true if the caller is the owner. */
+    is_owner: z.boolean().optional(),
+    /** Attached by the API on GET: true if the caller has bookmarked the Skill. */
+    bookmarked: z.boolean().optional(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+});
+export const createSkillInputSchema = skillSchema
+    .pick({
+    name: true,
+    slug: true,
+    description: true,
+    content: true,
+    visibility: true,
+    source_repo: true,
+    license: true,
+    category: true,
+    tags: true,
+    price_cents: true,
+    currency: true,
+})
+    .partial({
+    description: true,
+    content: true,
+    visibility: true,
+    source_repo: true,
+    license: true,
+    category: true,
+    tags: true,
+    price_cents: true,
+    currency: true,
+});
+export const updateSkillInputSchema = createSkillInputSchema.partial().extend({
+    commit_message: z.string().max(200).optional(),
+});
+export const skillSortSchema = z.enum(['trending', 'popular', 'newest', 'relevance']);
+export const skillSearchQuerySchema = z.object({
+    q: z.string().trim().max(200).optional(),
+    category: z.string().optional(),
+    tag: z.string().optional(),
+    sort: skillSortSchema.default('trending'),
+    limit: z.coerce.number().int().min(1).max(100).default(24),
+    offset: z.coerce.number().int().nonnegative().default(0),
+});

package/dist/types/index.d.ts

@@ -0,0 +1,19 @@
+export type UserPlan = 'free' | 'pro' | 'team';
+export type UserRole = 'user' | 'admin';
+export interface Profile {
+    id: string;
+    username: string | null;
+    display_name: string | null;
+    avatar_url: string | null;
+    github_username: string | null;
+    role: UserRole;
+    plan: UserPlan;
+    stripe_customer_id: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface AuthUser {
+    id: string;
+    email: string;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAA;AAC9C,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AAEvC,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;IACd,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;CACd"}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@prave/shared",
+  "version": "0.1.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "development": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas/index.d.ts",
+      "development": "./src/schemas/index.ts",
+      "import": "./dist/schemas/index.js",
+      "default": "./dist/schemas/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "development": "./src/types/index.ts",
+      "import": "./dist/types/index.js",
+      "default": "./dist/types/index.js"
+    }
+  },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}