@prave/shared 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './schemas/index.js';
+export * from './types/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './schemas/index.js';
+export * from './types/index.js';

package/dist/schemas/ai-description.schema.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+/**
+ * The structured JSON we force Claude to emit when generating a Skill
+ * description. Kept short + kebab-case tags so the shape matches what
+ * the Builder's meta sidebar already consumes.
+ */
+export declare const aiDescriptionOutputSchema: z.ZodObject<{
+    description: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    key_concepts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    tags: string[];
+    key_concepts: string[];
+    summary?: string | undefined;
+}, {
+    description: string;
+    tags?: string[] | undefined;
+    summary?: string | undefined;
+    key_concepts?: string[] | undefined;
+}>;
+export type AiDescriptionOutput = z.infer<typeof aiDescriptionOutputSchema>;
+/**
+ * Persisted row shape, mirrors `public.skill_ai_descriptions`. `cached`
+ * is attached by the API when we short-circuit on a hash hit — lets the
+ * UI show a subtle "served from cache" affordance.
+ */
+export declare const skillAiDescriptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    skill_id: z.ZodString;
+    model: z.ZodString;
+    content_hash: z.ZodString;
+    description: z.ZodString;
+    summary: z.ZodNullable<z.ZodString>;
+    tags: z.ZodArray<z.ZodString, "many">;
+    key_concepts: z.ZodArray<z.ZodString, "many">;
+    generated_by: z.ZodNullable<z.ZodString>;
+    input_tokens: z.ZodNullable<z.ZodNumber>;
+    output_tokens: z.ZodNullable<z.ZodNumber>;
+    created_at: z.ZodString;
+    cached: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    tags: string[];
+    created_at: string;
+    skill_id: string;
+    summary: string | null;
+    key_concepts: string[];
+    model: string;
+    content_hash: string;
+    generated_by: string | null;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    cached?: boolean | undefined;
+}, {
+    id: string;
+    description: string;
+    tags: string[];
+    created_at: string;
+    skill_id: string;
+    summary: string | null;
+    key_concepts: string[];
+    model: string;
+    content_hash: string;
+    generated_by: string | null;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    cached?: boolean | undefined;
+}>;
+export type SkillAiDescription = z.infer<typeof skillAiDescriptionSchema>;
+export declare const generateDescriptionInputSchema: z.ZodObject<{
+    /** Force a fresh generation even if a cached row matches the hash. */
+    force: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    force?: boolean | undefined;
+}, {
+    force?: boolean | undefined;
+}>;
+export type GenerateDescriptionInput = z.infer<typeof generateDescriptionInputSchema>;
+//# sourceMappingURL=ai-description.schema.d.ts.map

package/dist/schemas/ai-description.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-description.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/ai-description.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAKpC,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,8BAA8B;IACzC,sEAAsE;;;;;;EAEtE,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}

package/dist/schemas/ai-description.schema.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+/**
+ * The structured JSON we force Claude to emit when generating a Skill
+ * description. Kept short + kebab-case tags so the shape matches what
+ * the Builder's meta sidebar already consumes.
+ */
+export const aiDescriptionOutputSchema = z.object({
+    description: z.string().min(1).max(500),
+    summary: z.string().min(1).max(800).optional(),
+    tags: z.array(z.string().min(1).max(40)).max(12).default([]),
+    key_concepts: z.array(z.string().min(1).max(80)).max(8).default([]),
+});
+/**
+ * Persisted row shape, mirrors `public.skill_ai_descriptions`. `cached`
+ * is attached by the API when we short-circuit on a hash hit — lets the
+ * UI show a subtle "served from cache" affordance.
+ */
+export const skillAiDescriptionSchema = z.object({
+    id: z.string().uuid(),
+    skill_id: z.string().uuid(),
+    model: z.string(),
+    content_hash: z.string(),
+    description: z.string(),
+    summary: z.string().nullable(),
+    tags: z.array(z.string()),
+    key_concepts: z.array(z.string()),
+    generated_by: z.string().uuid().nullable(),
+    input_tokens: z.number().int().nullable(),
+    output_tokens: z.number().int().nullable(),
+    created_at: z.string().datetime(),
+    cached: z.boolean().optional(),
+});
+export const generateDescriptionInputSchema = z.object({
+    /** Force a fresh generation even if a cached row matches the hash. */
+    force: z.boolean().optional(),
+});

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const apiResponseSchema: <T extends z.ZodTypeAny>(data: T) => z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodNullable<T>;
+    error: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    success: z.ZodBoolean;
+    data: z.ZodNullable<T>;
+    error: z.ZodNullable<z.ZodString>;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    success: z.ZodBoolean;
+    data: z.ZodNullable<T>;
+    error: z.ZodNullable<z.ZodString>;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
+export type ApiResponse<T> = {
+    success: boolean;
+    data: T | null;
+    error: string | null;
+};
+export declare const ok: <T>(data: T) => ApiResponse<T>;
+export declare const fail: (error: string) => ApiResponse<null>;
+//# sourceMappingURL=api-response.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api-response.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/api-response.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC;;;;;;;;;;;;iEAK7D,CAAA;AAEJ,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,CAAC,GAAG,IAAI,CAAA;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,MAAM,CAAC,KAAG,WAAW,CAAC,CAAC,CAA2C,CAAA;AACxF,eAAO,MAAM,IAAI,GAAI,OAAO,MAAM,KAAG,WAAW,CAAC,IAAI,CAA4C,CAAA"}

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const apiResponseSchema = (data) => z.object({
+    success: z.boolean(),
+    data: data.nullable(),
+    error: z.string().nullable(),
+});
+export const ok = (data) => ({ success: true, data, error: null });
+export const fail = (error) => ({ success: false, data: null, error });

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export declare const planSchema: z.ZodEnum<["free", "pro", "team"]>;
+export type Plan = z.infer<typeof planSchema>;
+export declare const subscriptionStatusSchema: z.ZodEnum<["active", "trialing", "past_due", "canceled", "incomplete", "incomplete_expired", "unpaid"]>;
+export type SubscriptionStatus = z.infer<typeof subscriptionStatusSchema>;
+/**
+ * The slim profile + billing snapshot the Settings/Billing UI consumes.
+ * The API layers this on top of `profiles` so the front-end never needs
+ * to talk to Stripe directly.
+ */
+export declare const billingProfileSchema: z.ZodObject<{
+    plan: z.ZodEnum<["free", "pro", "team"]>;
+    stripe_customer_id: z.ZodNullable<z.ZodString>;
+    stripe_subscription_id: z.ZodNullable<z.ZodString>;
+    subscription_status: z.ZodNullable<z.ZodEnum<["active", "trialing", "past_due", "canceled", "incomplete", "incomplete_expired", "unpaid"]>>;
+    current_period_end: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    plan: "free" | "pro" | "team";
+    stripe_customer_id: string | null;
+    stripe_subscription_id: string | null;
+    subscription_status: "active" | "trialing" | "past_due" | "canceled" | "incomplete" | "incomplete_expired" | "unpaid" | null;
+    current_period_end: string | null;
+}, {
+    plan: "free" | "pro" | "team";
+    stripe_customer_id: string | null;
+    stripe_subscription_id: string | null;
+    subscription_status: "active" | "trialing" | "past_due" | "canceled" | "incomplete" | "incomplete_expired" | "unpaid" | null;
+    current_period_end: string | null;
+}>;
+export type BillingProfile = z.infer<typeof billingProfileSchema>;
+export declare const billingCheckoutInputSchema: z.ZodObject<{
+    plan: z.ZodEnum<["pro", "team"]>;
+}, "strip", z.ZodTypeAny, {
+    plan: "pro" | "team";
+}, {
+    plan: "pro" | "team";
+}>;
+export type BillingCheckoutInput = z.infer<typeof billingCheckoutInputSchema>;
+export declare const billingCheckoutResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    session_id: string;
+}, {
+    url: string;
+    session_id: string;
+}>;
+export type BillingCheckoutResponse = z.infer<typeof billingCheckoutResponseSchema>;
+export declare const portalSessionResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>;
+export type PortalSessionResponse = z.infer<typeof portalSessionResponseSchema>;
+//# sourceMappingURL=billing.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"billing.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/billing.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,UAAU,oCAAkC,CAAA;AACzD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAE7C,eAAO,MAAM,wBAAwB,yGAQnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAM/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,0BAA0B;;;;;;EAErC,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,eAAO,MAAM,6BAA6B;;;;;;;;;EAGxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,2BAA2B;;;;;;EAEtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

package/dist/schemas/billing.schema.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export const planSchema = z.enum(['free', 'pro', 'team']);
+export const subscriptionStatusSchema = z.enum([
+    'active',
+    'trialing',
+    'past_due',
+    'canceled',
+    'incomplete',
+    'incomplete_expired',
+    'unpaid',
+]);
+/**
+ * The slim profile + billing snapshot the Settings/Billing UI consumes.
+ * The API layers this on top of `profiles` so the front-end never needs
+ * to talk to Stripe directly.
+ */
+export const billingProfileSchema = z.object({
+    plan: planSchema,
+    stripe_customer_id: z.string().nullable(),
+    stripe_subscription_id: z.string().nullable(),
+    subscription_status: subscriptionStatusSchema.nullable(),
+    current_period_end: z.string().datetime().nullable(),
+});
+export const billingCheckoutInputSchema = z.object({
+    plan: z.enum(['pro', 'team']),
+});
+export const billingCheckoutResponseSchema = z.object({
+    url: z.string().url(),
+    session_id: z.string(),
+});
+export const portalSessionResponseSchema = z.object({
+    url: z.string().url(),
+});

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export declare const cliDeviceCodeStatusSchema: z.ZodEnum<["pending", "authorized", "expired"]>;
+export type CliDeviceCodeStatus = z.infer<typeof cliDeviceCodeStatusSchema>;
+export declare const cliDeviceCodeSchema: z.ZodObject<{
+    device_code: z.ZodString;
+    status: z.ZodEnum<["pending", "authorized", "expired"]>;
+    created_at: z.ZodString;
+    expires_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "authorized" | "expired";
+    created_at: string;
+    device_code: string;
+    expires_at: string;
+}, {
+    status: "pending" | "authorized" | "expired";
+    created_at: string;
+    device_code: string;
+    expires_at: string;
+}>;
+export type CliDeviceCode = z.infer<typeof cliDeviceCodeSchema>;
+export declare const cliTokenResponseSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodString;
+    user_id: z.ZodString;
+    email: z.ZodString;
+    expires_at: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    expires_at: number;
+    access_token: string;
+    refresh_token: string;
+    user_id: string;
+    email: string;
+}, {
+    expires_at: number;
+    access_token: string;
+    refresh_token: string;
+    user_id: string;
+    email: string;
+}>;
+export type CliTokenResponse = z.infer<typeof cliTokenResponseSchema>;
+export declare const cliStartLoginInputSchema: z.ZodObject<{
+    device_code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    device_code: string;
+}, {
+    device_code: string;
+}>;
+export type CliStartLoginInput = z.infer<typeof cliStartLoginInputSchema>;
+export declare const cliAuthorizeInputSchema: z.ZodObject<{
+    device_code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    device_code: string;
+}, {
+    device_code: string;
+}>;
+export type CliAuthorizeInput = z.infer<typeof cliAuthorizeInputSchema>;
+//# sourceMappingURL=cli.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cli.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/cli.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,yBAAyB,iDAA+C,CAAA;AACrF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;EAMjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,wBAAwB;;;;;;EAEnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/schemas/cli.schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export const cliDeviceCodeStatusSchema = z.enum(['pending', 'authorized', 'expired']);
+export const cliDeviceCodeSchema = z.object({
+    device_code: z.string().uuid(),
+    status: cliDeviceCodeStatusSchema,
+    created_at: z.string().datetime(),
+    expires_at: z.string().datetime(),
+});
+export const cliTokenResponseSchema = z.object({
+    access_token: z.string(),
+    refresh_token: z.string(),
+    user_id: z.string().uuid(),
+    email: z.string().email(),
+    expires_at: z.number().int(),
+});
+export const cliStartLoginInputSchema = z.object({
+    device_code: z.string().uuid(),
+});
+export const cliAuthorizeInputSchema = z.object({
+    device_code: z.string().uuid(),
+});

package/dist/schemas/index.d.ts

@@ -0,0 +1,13 @@
+export * from './api-response.schema.js';
+export * from './skill.schema.js';
+export * from './skill-version.schema.js';
+export * from './cli.schema.js';
+export * from './search.schema.js';
+export * from './ai-description.schema.js';
+export * from './skill-dependency.schema.js';
+export * from './skill-test.schema.js';
+export * from './marketplace.schema.js';
+export * from './billing.schema.js';
+export * from './org.schema.js';
+export * from './install.schema.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,2BAA2B,CAAA;AACzC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,wBAAwB,CAAA;AACtC,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA"}

package/dist/schemas/index.js

@@ -0,0 +1,12 @@
+export * from './api-response.schema.js';
+export * from './skill.schema.js';
+export * from './skill-version.schema.js';
+export * from './cli.schema.js';
+export * from './search.schema.js';
+export * from './ai-description.schema.js';
+export * from './skill-dependency.schema.js';
+export * from './skill-test.schema.js';
+export * from './marketplace.schema.js';
+export * from './billing.schema.js';
+export * from './org.schema.js';
+export * from './install.schema.js';

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

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+/** A single `installs` row — buyer-side install receipt. */
+export declare const installSchema: z.ZodObject<{
+    id: z.ZodString;
+    user_id: z.ZodString;
+    skill_id: z.ZodString;
+    version: z.ZodNullable<z.ZodNumber>;
+    installed_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    skill_id: string;
+    version: number | null;
+    user_id: string;
+    installed_at: string;
+}, {
+    id: string;
+    skill_id: string;
+    version: number | null;
+    user_id: string;
+    installed_at: string;
+}>;
+export type Install = z.infer<typeof installSchema>;
+/** Hydrated row used by the Installs tab + CLI list. */
+export declare const installRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    user_id: z.ZodString;
+    skill_id: z.ZodString;
+    version: z.ZodNullable<z.ZodNumber>;
+    installed_at: z.ZodString;
+} & {
+    skill: z.ZodObject<Pick<{
+        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>;
+        purchased: z.ZodOptional<z.ZodBoolean>;
+        is_owner: z.ZodOptional<z.ZodBoolean>;
+        bookmarked: z.ZodOptional<z.ZodBoolean>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, "id" | "name" | "slug" | "description" | "visibility" | "license" | "updated_at">, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        slug: string;
+        description: string | null;
+        visibility: "public" | "private" | "org";
+        license: string;
+        updated_at: string;
+    }, {
+        id: string;
+        name: string;
+        slug: string;
+        description: string | null;
+        updated_at: string;
+        visibility?: "public" | "private" | "org" | undefined;
+        license?: string | undefined;
+    }>;
+    /** Latest version from `skill_versions`, attached by the API. */
+    latest_version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    skill_id: string;
+    version: number | null;
+    user_id: string;
+    installed_at: string;
+    skill: {
+        id: string;
+        name: string;
+        slug: string;
+        description: string | null;
+        visibility: "public" | "private" | "org";
+        license: string;
+        updated_at: string;
+    };
+    latest_version?: number | null | undefined;
+}, {
+    id: string;
+    skill_id: string;
+    version: number | null;
+    user_id: string;
+    installed_at: string;
+    skill: {
+        id: string;
+        name: string;
+        slug: string;
+        description: string | null;
+        updated_at: string;
+        visibility?: "public" | "private" | "org" | undefined;
+        license?: string | undefined;
+    };
+    latest_version?: number | null | undefined;
+}>;
+export type InstallRow = z.infer<typeof installRowSchema>;
+export declare const recordInstallInputSchema: z.ZodObject<{
+    /** Optional version pin — defaults to the latest version of the skill. */
+    version: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    version?: number | undefined;
+}, {
+    version?: number | undefined;
+}>;
+export type RecordInstallInput = z.infer<typeof recordInstallInputSchema>;
+//# sourceMappingURL=install.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"install.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/install.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,4DAA4D;AAC5D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;EAMxB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEnD,wDAAwD;AACxD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAU3B,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjE,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,wBAAwB;IACnC,0EAA0E;;;;;;EAE1E,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/schemas/install.schema.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { skillSchema } from './skill.schema.js';
+/** A single `installs` row — buyer-side install receipt. */
+export const installSchema = z.object({
+    id: z.string().uuid(),
+    user_id: z.string().uuid(),
+    skill_id: z.string().uuid(),
+    version: z.number().int().nullable(),
+    installed_at: z.string().datetime(),
+});
+/** Hydrated row used by the Installs tab + CLI list. */
+export const installRowSchema = installSchema.extend({
+    skill: skillSchema.pick({
+        id: true,
+        slug: true,
+        name: true,
+        description: true,
+        visibility: true,
+        license: true,
+        updated_at: true,
+    }),
+    /** Latest version from `skill_versions`, attached by the API. */
+    latest_version: z.number().int().nullable().optional(),
+});
+export const recordInstallInputSchema = z.object({
+    /** Optional version pin — defaults to the latest version of the skill. */
+    version: z.number().int().positive().optional(),
+});