interface Skill {
  id: string;
  slug: string;
  name: string;
  description: string | null;
  price: string;
  currency: string;
  endpoint: string;
  inputSchema: Record<string, unknown> | null;
  outputSchema: Record<string, unknown> | null;
  paymentAddress: string;
  isActive: boolean;
  creatorId: string;
  createdAt: string;
  updatedAt: string;
  groups?: SkillGroup[];  // Groups this skill belongs to
}

interface SkillGroup {
  id: string;
  slug: string;
  name: string;
  description: string | null;
  icon: string | null;
  creatorId: string;
  isActive: boolean;
  createdAt: string;
  updatedAt: string;
}
 
interface SkillGroupWithSkills extends SkillGroup {
  skills: Skill[];
  creator: Creator | null;
}

interface Creator {
  id: string;
  walletAddress: string;
  name: string | null;
  avatar: string | null;
  bio: string | null;
  createdAt: string;
}

interface Review {
  id: string;
  skillId: string;
  consumerAddress: string;
  score: number;
  comment: string | null;
  createdAt: string;
}

interface SearchFilters {
  category?: string;
  minPrice?: string;
  maxPrice?: string;
  creator?: string;
  group?: string;  // Filter by group slug
}

interface SkillzMarketOptions {
  apiUrl?: string;
  wallet?: WalletConfig;
  network?: `${string}:${string}`;
}

import type { Hex } from 'viem';
import type { PrivateKeyAccount } from 'viem/accounts';
 
type WalletConfig = PrivateKeyAccount | Hex;

interface SkillOptions {
  price: string;
  description?: string;
  timeout?: number;
  inputSchema?: JsonSchema;
  outputSchema?: JsonSchema;
  groups?: string[];  // Per-skill groups (merged with global)
}

interface JsonSchema {
  type: string;
  properties?: Record<string, JsonSchema>;
  required?: string[];
  items?: JsonSchema;
  [key: string]: unknown;
}

type SkillHandler<TInput = unknown, TOutput = unknown> = (
  input: TInput
) => Promise<TOutput>;

interface SkillDefinition<TInput = unknown, TOutput = unknown> {
  options: SkillOptions;
  handler: SkillHandler<TInput, TOutput>;
  parsedPrice: ParsedPrice;
}

type SkillsMap = Record<string, SkillDefinition<any, any>>;

interface ParsedPrice {
  amount: string;
  currency: 'USDC';
}

interface ServeOptions {
  port?: number;
  wallet?: string;           // 42-char address or 66-char private key
  apiKey?: string;           // API key for registration
  network?: `${string}:${string}`;
  facilitatorUrl?: string;
  appName?: string;
  onCall?: (skillName: string, input: unknown) => void;
  onError?: (skillName: string, error: Error) => void;
  register?: RegistrationOptions;
  trackCalls?: boolean;
  apiUrl?: string;
}

interface BatchOptions {
  concurrency?: number;  // Max concurrent requests (default: 5)
}

interface RegistrationOptions {
  apiUrl?: string;
  endpoint: string;
  enabled?: boolean;
  onError?: 'throw' | 'warn' | 'silent';
  groups?: string[];   // Global groups (merged with per-skill)
  batch?: BatchOptions;
}

interface RegistrationResult {
  name: string;
  success: boolean;
  slug?: string;
  error?: string;
}

interface RegisterOptions {
  apiKey: string;
  paymentAddress: Address;
  endpoint: string;
  apiUrl?: string;
  onError?: 'throw' | 'warn' | 'silent';
  groups?: string[];   // Global groups (merged with per-skill)
  batch?: BatchOptions;
}

interface SkillUpdateData {
  description?: string;
  price?: string;
  groups?: string[];  // Replaces existing groups
  inputSchema?: JsonSchema;
  outputSchema?: JsonSchema;
  isActive?: boolean;
}

interface UpdateResult {
  slug: string;
  success: boolean;
  error?: string;
}

interface UpdateOptions {
  apiKey: string;
  apiUrl?: string;
}

interface ConfigStatus {
  configured: boolean;
  apiKey: boolean;
  walletAddress: boolean;
  issues: string[];
}

import type {
  Skill,
  SkillGroup,
  SkillGroupWithSkills,
  Creator,
  Review,
  SearchFilters,
  SkillzMarketOptions,
  WalletConfig,
} from '@skillzmarket/sdk';

import type {
  SkillOptions,
  SkillHandler,
  SkillDefinition,
  SkillsMap,
  ServeOptions,
  RegistrationOptions,
  RegistrationResult,
  RegisterOptions,
  ParsedPrice,
  JsonSchema,
  BatchOptions,
  SkillUpdateData,
  UpdateResult,
  UpdateOptions,
} from '@skillzmarket/sdk/creator';

import { SkillzMarket } from '@skillzmarket/sdk';
import type { Skill, SearchFilters } from '@skillzmarket/sdk';
 
const market = new SkillzMarket({ wallet: '0x...' });
 
const filters: SearchFilters = {
  category: 'text',
  maxPrice: '0.01',
};
 
const skills: Skill[] = await market.search('AI', filters);

import { skill, serve, checkConfig } from '@skillzmarket/sdk/creator';
import type { SkillOptions, ServeOptions } from '@skillzmarket/sdk/creator';
 
// Check configuration
const config = checkConfig();
if (!config.configured) {
  console.error('Issues:', config.issues);
  process.exit(1);
}
 
interface MyInput {
  text: string;
}
 
interface MyOutput {
  result: string;
}
 
const options: SkillOptions = {
  price: '$0.001',
  description: 'Process text',
};
 
const mySkill = skill<MyInput, MyOutput>(options, async ({ text }) => {
  return { result: text.toUpperCase() };
});
 
const serveOptions: ServeOptions = {
  port: 3002,
  register: {
    endpoint: 'https://example.com',
    enabled: true,
  },
};
 
serve({ mySkill }, serveOptions);