@hasna/connectors 1.3.0 → 1.3.1

package/bin/index.js

@@ -11851,7 +11851,7 @@ import chalk2 from "chalk";
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.2.1",
+  version: "1.3.1",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {

package/bin/mcp.js

@@ -27082,7 +27082,7 @@ init_strip();
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.2.1",
+  version: "1.3.1",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {

package/connectors/connect-huggingface/src/api/client.ts

@@ -124,6 +124,11 @@ export class HuggingFaceClient {
     return this.request<T>(path, { method: 'DELETE', params });
   }
 
+  /** Get the raw API key (needed by InferenceApi for direct fetch) */
+  getApiKey(): string {
+    return this.apiKey;
+  }
+
   /**
    * Get a preview of the API key (for display/debugging)
    */

package/connectors/connect-huggingface/src/api/datasets.ts

@@ -0,0 +1,73 @@
+import type { HuggingFaceClient } from './client';
+
+export interface DatasetSearchOptions {
+  search?: string;
+  author?: string;
+  filter?: string;
+  sort?: 'likes' | 'downloads' | 'trending' | 'lastModified';
+  direction?: 'asc' | 'desc';
+  limit?: number;
+  full?: boolean;
+}
+
+export interface DatasetInfo {
+  _id: string;
+  id: string;
+  author?: string;
+  sha?: string;
+  lastModified?: string;
+  private?: boolean;
+  gated?: boolean | string;
+  tags?: string[];
+  downloads?: number;
+  likes?: number;
+  description?: string;
+  citation?: string;
+  cardData?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface DatasetSplit {
+  dataset: string;
+  config: string;
+  split: string;
+  num_rows: number;
+  num_bytes: number;
+}
+
+export class DatasetsApi {
+  constructor(private readonly client: HuggingFaceClient) {}
+
+  /** Search/list datasets */
+  async search(options: DatasetSearchOptions = {}): Promise<DatasetInfo[]> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (options.search) params.search = options.search;
+    if (options.author) params.author = options.author;
+    if (options.filter) params.filter = options.filter;
+    if (options.sort) params.sort = options.sort;
+    if (options.direction) params.direction = options.direction === 'desc' ? '-1' : '1';
+    if (options.limit) params.limit = options.limit;
+    if (options.full) params.full = true;
+
+    return this.client.request<DatasetInfo[]>('/datasets', { params });
+  }
+
+  /** Get a single dataset by ID */
+  async get(datasetId: string): Promise<DatasetInfo> {
+    return this.client.request<DatasetInfo>(`/datasets/${datasetId}`);
+  }
+
+  /** Preview first N rows of a dataset split */
+  async preview(datasetId: string, config = 'default', split = 'train', rows = 10): Promise<unknown> {
+    // Uses the datasets-server API
+    const url = `https://datasets-server.huggingface.co/first-rows?dataset=${encodeURIComponent(datasetId)}&config=${config}&split=${split}&rows=${rows}`;
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${this.client.getApiKey()}` },
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Dataset preview failed (${response.status}): ${text}`);
+    }
+    return response.json();
+  }
+}

package/connectors/connect-huggingface/src/api/index.ts

@@ -1,6 +1,9 @@
 import type { HuggingFaceConfig } from '../types';
 import { HuggingFaceClient } from './client';
-import { ExampleApi } from './example';
+import { ModelsApi } from './models';
+import { InferenceApi } from './inference';
+import { DatasetsApi } from './datasets';
+import { SpacesApi } from './spaces';
 
 /**
  * Main HuggingFace API class
@@ -8,42 +11,37 @@ import { ExampleApi } from './example';
 export class HuggingFace {
   private readonly client: HuggingFaceClient;
 
-  // API modules - add more as needed
-  public readonly example: ExampleApi;
+  public readonly models: ModelsApi;
+  public readonly inference: InferenceApi;
+  public readonly datasets: DatasetsApi;
+  public readonly spaces: SpacesApi;
 
   constructor(config: HuggingFaceConfig) {
     this.client = new HuggingFaceClient(config);
-    this.example = new ExampleApi(this.client);
+    this.models = new ModelsApi(this.client);
+    this.inference = new InferenceApi(this.client);
+    this.datasets = new DatasetsApi(this.client);
+    this.spaces = new SpacesApi(this.client);
   }
 
-  /**
-   * Create a client from environment variables
-   * Looks for HUGGINGFACE_API_KEY or HF_TOKEN
-   */
   static fromEnv(): HuggingFace {
     const apiKey = process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN;
     const apiSecret = process.env.HUGGINGFACE_API_SECRET;
-
-    if (!apiKey) {
-      throw new Error('HUGGINGFACE_API_KEY or HF_TOKEN environment variable is required');
-    }
+    if (!apiKey) throw new Error('HUGGINGFACE_API_KEY or HF_TOKEN environment variable is required');
     return new HuggingFace({ apiKey, apiSecret });
   }
 
-  /**
-   * Get a preview of the API key (for debugging)
-   */
   getApiKeyPreview(): string {
     return this.client.getApiKeyPreview();
   }
 
-  /**
-   * Get the underlying client for direct API access
-   */
   getClient(): HuggingFaceClient {
     return this.client;
   }
 }
 
 export { HuggingFaceClient } from './client';
-export { ExampleApi } from './example';
+export { ModelsApi } from './models';
+export { InferenceApi } from './inference';
+export { DatasetsApi } from './datasets';
+export { SpacesApi } from './spaces';

package/connectors/connect-huggingface/src/api/inference.ts

@@ -0,0 +1,100 @@
+import type { HuggingFaceClient } from './client';
+
+const INFERENCE_URL = 'https://api-inference.huggingface.co/models';
+
+export interface TextGenerationOptions {
+  max_new_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  top_k?: number;
+  repetition_penalty?: number;
+  return_full_text?: boolean;
+  stop?: string[];
+}
+
+export interface TextGenerationResult {
+  generated_text: string;
+}
+
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface ChatCompletionResult {
+  choices: Array<{
+    message: { role: string; content: string };
+    finish_reason: string;
+    index: number;
+  }>;
+  model: string;
+  usage?: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
+}
+
+export class InferenceApi {
+  constructor(private readonly client: HuggingFaceClient) {}
+
+  /** Run text generation inference */
+  async textGeneration(
+    model: string,
+    prompt: string,
+    options: TextGenerationOptions = {}
+  ): Promise<TextGenerationResult[]> {
+    const response = await fetch(`${INFERENCE_URL}/${model}`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.client.getApiKey()}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        inputs: prompt,
+        parameters: {
+          max_new_tokens: options.max_new_tokens ?? 256,
+          temperature: options.temperature,
+          top_p: options.top_p,
+          top_k: options.top_k,
+          repetition_penalty: options.repetition_penalty,
+          return_full_text: options.return_full_text ?? false,
+          stop: options.stop,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Inference failed (${response.status}): ${text}`);
+    }
+
+    return response.json();
+  }
+
+  /** Chat completion via HF Inference API (for chat models) */
+  async chat(
+    model: string,
+    messages: ChatMessage[],
+    options: Omit<TextGenerationOptions, 'return_full_text'> = {}
+  ): Promise<ChatCompletionResult> {
+    const response = await fetch(`${INFERENCE_URL}/${model}/v1/chat/completions`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.client.getApiKey()}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        max_tokens: options.max_new_tokens ?? 256,
+        temperature: options.temperature,
+        top_p: options.top_p,
+        stop: options.stop,
+      }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Chat inference failed (${response.status}): ${text}`);
+    }
+
+    return response.json();
+  }
+}

package/connectors/connect-huggingface/src/api/models.ts

@@ -0,0 +1,66 @@
+import type { HuggingFaceClient } from './client';
+
+export interface ModelSearchOptions {
+  search?: string;
+  author?: string;
+  filter?: string;       // task filter: text-generation, text2text-generation, etc
+  library?: string;      // transformers, gguf, pytorch, etc
+  sort?: 'likes' | 'downloads' | 'trending' | 'lastModified';
+  direction?: 'asc' | 'desc';
+  limit?: number;
+  full?: boolean;        // include all fields
+}
+
+export interface ModelInfo {
+  _id: string;
+  id: string;            // e.g. "meta-llama/Meta-Llama-3-8B"
+  modelId: string;
+  author?: string;
+  sha?: string;
+  lastModified?: string;
+  private?: boolean;
+  disabled?: boolean;
+  gated?: boolean | string;
+  pipeline_tag?: string;
+  tags?: string[];
+  downloads?: number;
+  likes?: number;
+  library_name?: string;
+  [key: string]: unknown;
+}
+
+export interface ModelFile {
+  rfilename: string;
+  size?: number;
+  blobId?: string;
+  lfs?: { size: number; sha256: string; pointerSize: number };
+}
+
+export class ModelsApi {
+  constructor(private readonly client: HuggingFaceClient) {}
+
+  /** Search/list models */
+  async search(options: ModelSearchOptions = {}): Promise<ModelInfo[]> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (options.search) params.search = options.search;
+    if (options.author) params.author = options.author;
+    if (options.filter) params.filter = options.filter;
+    if (options.library) params.library = options.library;
+    if (options.sort) params.sort = options.sort;
+    if (options.direction) params.direction = options.direction === 'desc' ? '-1' : '1';
+    if (options.limit) params.limit = options.limit;
+    if (options.full) params.full = true;
+
+    return this.client.request<ModelInfo[]>('/models', { params });
+  }
+
+  /** Get a single model by ID (e.g. "meta-llama/Meta-Llama-3-8B") */
+  async get(modelId: string): Promise<ModelInfo> {
+    return this.client.request<ModelInfo>(`/models/${modelId}`);
+  }
+
+  /** List files in a model repo */
+  async files(modelId: string): Promise<ModelFile[]> {
+    return this.client.request<ModelFile[]>(`/models/${modelId}/tree/main`);
+  }
+}

package/connectors/connect-huggingface/src/api/spaces.ts

@@ -0,0 +1,42 @@
+import type { HuggingFaceClient } from './client';
+
+export interface SpaceSearchOptions {
+  search?: string;
+  author?: string;
+  sort?: 'likes' | 'trending' | 'lastModified';
+  direction?: 'asc' | 'desc';
+  limit?: number;
+}
+
+export interface SpaceInfo {
+  _id: string;
+  id: string;
+  author?: string;
+  sha?: string;
+  lastModified?: string;
+  private?: boolean;
+  tags?: string[];
+  likes?: number;
+  sdk?: string;
+  runtime?: { stage: string; hardware?: { current?: string } };
+  [key: string]: unknown;
+}
+
+export class SpacesApi {
+  constructor(private readonly client: HuggingFaceClient) {}
+
+  async search(options: SpaceSearchOptions = {}): Promise<SpaceInfo[]> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (options.search) params.search = options.search;
+    if (options.author) params.author = options.author;
+    if (options.sort) params.sort = options.sort;
+    if (options.direction) params.direction = options.direction === 'desc' ? '-1' : '1';
+    if (options.limit) params.limit = options.limit;
+
+    return this.client.request<SpaceInfo[]>('/spaces', { params });
+  }
+
+  async get(spaceId: string): Promise<SpaceInfo> {
+    return this.client.request<SpaceInfo>(`/spaces/${spaceId}`);
+  }
+}

package/connectors/connect-huggingface/src/cli/index.ts

@@ -188,55 +188,167 @@ configCmd
   });
 
 // ============================================
-// Example API Commands - Replace with HuggingFace API commands
+// Models Commands
 // ============================================
-const exampleCmd = program
-  .command('example')
-  .description('Example API commands (replace with HuggingFace commands)');
+const modelsCmd = program.command('models').description('Search and browse HuggingFace models');
 
-exampleCmd
-  .command('list')
-  .description('List resources')
-  .option('-n, --max <number>', 'Maximum results', '10')
-  .action(async (opts) => {
+modelsCmd
+  .command('search')
+  .description('Search models')
+  .argument('[query]', 'Search query')
+  .option('--task <task>', 'Filter by task (text-generation, text2text-generation, etc)')
+  .option('--library <lib>', 'Filter by library (transformers, gguf, pytorch)')
+  .option('--author <author>', 'Filter by author')
+  .option('--sort <field>', 'Sort by: likes, downloads, trending, lastModified', 'trending')
+  .option('--limit <n>', 'Max results', '20')
+  .action(async (query, opts) => {
     try {
       const client = getClient();
-      const result = await client.example.list({ maxResults: parseInt(opts.max) });
-      print(result, getFormat(exampleCmd));
-    } catch (err) {
-      error(String(err));
-      process.exit(1);
-    }
+      const results = await client.models.search({
+        search: query, filter: opts.task, library: opts.library,
+        author: opts.author, sort: opts.sort, limit: parseInt(opts.limit),
+      });
+      print(results.map(m => ({ id: m.id, task: m.pipeline_tag, library: m.library_name, downloads: m.downloads, likes: m.likes })), getFormat(modelsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
   });
 
-exampleCmd
+modelsCmd
   .command('get <id>')
-  .description('Get a resource by ID')
-  .action(async (id: string) => {
+  .description('Get model details (e.g. meta-llama/Meta-Llama-3-8B)')
+  .action(async (id) => {
     try {
       const client = getClient();
-      const result = await client.example.get(id);
-      print(result, getFormat(exampleCmd));
-    } catch (err) {
-      error(String(err));
-      process.exit(1);
-    }
+      const result = await client.models.get(id);
+      print(result, getFormat(modelsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
   });
 
-exampleCmd
-  .command('create')
-  .description('Create a new resource')
-  .requiredOption('-n, --name <name>', 'Resource name')
-  .action(async (opts) => {
+modelsCmd
+  .command('files <id>')
+  .description('List files in a model repo')
+  .action(async (id) => {
     try {
       const client = getClient();
-      const result = await client.example.create({ name: opts.name });
-      success('Resource created!');
-      print(result, getFormat(exampleCmd));
-    } catch (err) {
-      error(String(err));
-      process.exit(1);
-    }
+      const files = await client.models.files(id);
+      print(files.map(f => ({ name: f.rfilename, size: f.lfs?.size ?? f.size ?? null })), getFormat(modelsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+// ============================================
+// Inference Commands
+// ============================================
+const inferCmd = program.command('inference').description('Run model inference via HF Inference API');
+
+inferCmd
+  .command('text-generation <model>')
+  .description('Generate text from a prompt')
+  .requiredOption('--prompt <text>', 'Input prompt')
+  .option('--max-tokens <n>', 'Max new tokens', '256')
+  .option('--temperature <t>', 'Temperature', '0.7')
+  .action(async (model, opts) => {
+    try {
+      const client = getClient();
+      const results = await client.inference.textGeneration(model, opts.prompt, {
+        max_new_tokens: parseInt(opts.maxTokens), temperature: parseFloat(opts.temperature),
+      });
+      print(results, getFormat(inferCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+inferCmd
+  .command('chat <model>')
+  .description('Chat completion (for chat models)')
+  .requiredOption('--messages <json>', 'Messages JSON array')
+  .option('--max-tokens <n>', 'Max new tokens', '256')
+  .option('--temperature <t>', 'Temperature', '0.7')
+  .action(async (model, opts) => {
+    try {
+      const messages = JSON.parse(opts.messages);
+      const client = getClient();
+      const result = await client.inference.chat(model, messages, {
+        max_new_tokens: parseInt(opts.maxTokens), temperature: parseFloat(opts.temperature),
+      });
+      print(result, getFormat(inferCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+// ============================================
+// Datasets Commands
+// ============================================
+const datasetsCmd = program.command('datasets').description('Search and browse HuggingFace datasets');
+
+datasetsCmd
+  .command('search')
+  .description('Search datasets')
+  .argument('[query]', 'Search query')
+  .option('--author <author>', 'Filter by author')
+  .option('--sort <field>', 'Sort by: likes, downloads, trending', 'trending')
+  .option('--limit <n>', 'Max results', '20')
+  .action(async (query, opts) => {
+    try {
+      const client = getClient();
+      const results = await client.datasets.search({
+        search: query, author: opts.author, sort: opts.sort, limit: parseInt(opts.limit),
+      });
+      print(results.map(d => ({ id: d.id, downloads: d.downloads, likes: d.likes, tags: d.tags?.slice(0, 5) })), getFormat(datasetsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+datasetsCmd
+  .command('get <id>')
+  .description('Get dataset details')
+  .action(async (id) => {
+    try {
+      const client = getClient();
+      const result = await client.datasets.get(id);
+      print(result, getFormat(datasetsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+datasetsCmd
+  .command('preview <id>')
+  .description('Preview first N rows of a dataset')
+  .option('--split <split>', 'Dataset split', 'train')
+  .option('--rows <n>', 'Number of rows', '10')
+  .action(async (id, opts) => {
+    try {
+      const client = getClient();
+      const result = await client.datasets.preview(id, 'default', opts.split, parseInt(opts.rows));
+      print(result, getFormat(datasetsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+// ============================================
+// Spaces Commands
+// ============================================
+const spacesCmd = program.command('spaces').description('Search and browse HuggingFace Spaces');
+
+spacesCmd
+  .command('search')
+  .description('Search spaces')
+  .argument('[query]', 'Search query')
+  .option('--author <author>', 'Filter by author')
+  .option('--sort <field>', 'Sort by: likes, trending', 'trending')
+  .option('--limit <n>', 'Max results', '20')
+  .action(async (query, opts) => {
+    try {
+      const client = getClient();
+      const results = await client.spaces.search({
+        search: query, author: opts.author, sort: opts.sort, limit: parseInt(opts.limit),
+      });
+      print(results.map(s => ({ id: s.id, sdk: s.sdk, likes: s.likes })), getFormat(spacesCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+spacesCmd
+  .command('get <id>')
+  .description('Get space details')
+  .action(async (id) => {
+    try {
+      const client = getClient();
+      const result = await client.spaces.get(id);
+      print(result, getFormat(spacesCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
   });
 
 // Parse and execute

package/connectors/connect-openai/src/api/images.ts

@@ -5,8 +5,20 @@ import type {
   ImageOptions,
 } from '../types';
 
+/** Models that use the new gpt-image API (different params than DALL-E) */
+const GPT_IMAGE_MODELS = ['gpt-image-1'];
+
+function isGptImage(model: string): boolean {
+  return GPT_IMAGE_MODELS.some((m) => model.startsWith(m));
+}
+
 /**
- * Images API (DALL-E)
+ * Images API — supports both DALL-E 3 and gpt-image-1
+ *
+ * gpt-image-1 differences:
+ *   - Uses `output_format` instead of `response_format`
+ *   - Does NOT support `style` parameter
+ *   - Does NOT support `response_format` parameter
  */
 export class ImagesApi {
   constructor(private readonly client: OpenAIClient) {}
@@ -18,13 +30,29 @@ export class ImagesApi {
     prompt: string,
     options: ImageOptions = {}
   ): Promise<ImageResponse> {
+    const model = options.model || 'dall-e-3';
+
+    if (isGptImage(model)) {
+      // gpt-image-1: different parameter set
+      const request: Record<string, unknown> = {
+        model,
+        prompt,
+        n: options.n || 1,
+      };
+      if (options.size !== undefined) request.size = options.size;
+      if (options.quality !== undefined) request.quality = options.quality;
+      // gpt-image-1 uses output_format, not response_format. No style param.
+      request.output_format = 'url';
+      return this.client.post<ImageResponse>('/images/generations', request);
+    }
+
+    // DALL-E 3: original parameter set
     const request: ImageGenerateRequest = {
-      model: options.model || 'dall-e-3',
+      model,
       prompt,
       n: options.n || 1,
       response_format: 'url',
     };
-
     if (options.size !== undefined) request.size = options.size;
     if (options.quality !== undefined) request.quality = options.quality;
     if (options.style !== undefined) request.style = options.style;
@@ -54,22 +82,38 @@ export class ImagesApi {
     prompt: string,
     options: Omit<ImageOptions, 'n'> = {}
   ): Promise<string> {
+    const model = options.model || 'dall-e-3';
+
+    if (isGptImage(model)) {
+      const request: Record<string, unknown> = {
+        model,
+        prompt,
+        n: 1,
+        output_format: 'b64_json',
+      };
+      if (options.size !== undefined) request.size = options.size;
+      if (options.quality !== undefined) request.quality = options.quality;
+
+      const response = await this.client.post<ImageResponse>('/images/generations', request);
+      const b64 = response.data[0]?.b64_json;
+      if (!b64) throw new Error('No image data in response');
+      return b64;
+    }
+
+    // DALL-E 3
     const request: ImageGenerateRequest = {
-      model: options.model || 'dall-e-3',
+      model,
       prompt,
       n: 1,
       response_format: 'b64_json',
     };
-
     if (options.size !== undefined) request.size = options.size;
     if (options.quality !== undefined) request.quality = options.quality;
     if (options.style !== undefined) request.style = options.style;
 
     const response = await this.client.post<ImageResponse>('/images/generations', request);
     const b64 = response.data[0]?.b64_json;
-    if (!b64) {
-      throw new Error('No image data in response');
-    }
+    if (!b64) throw new Error('No image data in response');
     return b64;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/connectors",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Open source connector library - Install API connectors with a single command",
   "type": "module",
   "bin": {

package/connectors/connect-huggingface/src/api/example.ts

@@ -1,48 +0,0 @@
-import type { HuggingFaceClient } from './client';
-import type { ExampleResource, ExampleListResponse, ExampleCreateParams } from '../types';
-
-/**
- * Example API module - demonstrates the pattern for API modules
- * Replace with actual HuggingFace API endpoints (models, datasets, spaces, etc.)
- */
-export class ExampleApi {
-  constructor(private readonly client: HuggingFaceClient) {}
-
-  /**
-   * List resources with optional pagination
-   */
-  async list(options?: { maxResults?: number; pageToken?: string }): Promise<ExampleListResponse> {
-    return this.client.get<ExampleListResponse>('/resources', {
-      max_results: options?.maxResults,
-      page_token: options?.pageToken,
-    });
-  }
-
-  /**
-   * Get a single resource by ID
-   */
-  async get(id: string): Promise<ExampleResource> {
-    return this.client.get<ExampleResource>(`/resources/${id}`);
-  }
-
-  /**
-   * Create a new resource
-   */
-  async create(params: ExampleCreateParams): Promise<ExampleResource> {
-    return this.client.post<ExampleResource>('/resources', params);
-  }
-
-  /**
-   * Update an existing resource
-   */
-  async update(id: string, params: Partial<ExampleCreateParams>): Promise<ExampleResource> {
-    return this.client.patch<ExampleResource>(`/resources/${id}`, params);
-  }
-
-  /**
-   * Delete a resource
-   */
-  async delete(id: string): Promise<void> {
-    await this.client.delete(`/resources/${id}`);
-  }
-}