0
# Generated API Clients
1

2
Complete Kubernetes API coverage with type-safe client classes for all API groups. The library provides auto-generated clients that mirror the official Kubernetes API structure with full CRUD operations for all resource types.
3

4
## Capabilities
5

6
### Core API Clients
7

8
The most commonly used Kubernetes API groups for managing core resources.
9

10
```typescript { .api }
11
/**
12
 * Core Kubernetes resources (pods, services, configmaps, etc.)
13
 */
14
class CoreV1Api {
15
  // Pod operations
16
  listNamespacedPod(namespace: string, options?: ListOptions): Promise<{ body: V1PodList }>;
17
  createNamespacedPod(namespace: string, body: V1Pod, options?: CreateOptions): Promise<{ body: V1Pod }>;
18
  readNamespacedPod(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Pod }>;
19
  replaceNamespacedPod(name: string, namespace: string, body: V1Pod, options?: ReplaceOptions): Promise<{ body: V1Pod }>;
20
  deleteNamespacedPod(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
21
  patchNamespacedPod(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1Pod }>;
22
  
23
  // Service operations
24
  listNamespacedService(namespace: string, options?: ListOptions): Promise<{ body: V1ServiceList }>;
25
  createNamespacedService(namespace: string, body: V1Service, options?: CreateOptions): Promise<{ body: V1Service }>;
26
  readNamespacedService(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Service }>;
27
  replaceNamespacedService(name: string, namespace: string, body: V1Service, options?: ReplaceOptions): Promise<{ body: V1Service }>;
28
  deleteNamespacedService(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
29
  
30
  // ConfigMap operations
31
  listNamespacedConfigMap(namespace: string, options?: ListOptions): Promise<{ body: V1ConfigMapList }>;
32
  createNamespacedConfigMap(namespace: string, body: V1ConfigMap, options?: CreateOptions): Promise<{ body: V1ConfigMap }>;
33
  readNamespacedConfigMap(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1ConfigMap }>;
34
  replaceNamespacedConfigMap(name: string, namespace: string, body: V1ConfigMap, options?: ReplaceOptions): Promise<{ body: V1ConfigMap }>;
35
  deleteNamespacedConfigMap(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
36
  
37
  // Secret operations
38
  listNamespacedSecret(namespace: string, options?: ListOptions): Promise<{ body: V1SecretList }>;
39
  createNamespacedSecret(namespace: string, body: V1Secret, options?: CreateOptions): Promise<{ body: V1Secret }>;
40
  readNamespacedSecret(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Secret }>;
41
  replaceNamespacedSecret(name: string, namespace: string, body: V1Secret, options?: ReplaceOptions): Promise<{ body: V1Secret }>;
42
  deleteNamespacedSecret(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
43
  
44
  // Namespace operations
45
  listNamespace(options?: ListOptions): Promise<{ body: V1NamespaceList }>;
46
  createNamespace(body: V1Namespace, options?: CreateOptions): Promise<{ body: V1Namespace }>;
47
  readNamespace(name: string, options?: ReadOptions): Promise<{ body: V1Namespace }>;
48
  replaceNamespace(name: string, body: V1Namespace, options?: ReplaceOptions): Promise<{ body: V1Namespace }>;
49
  deleteNamespace(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
50
  
51
  // Node operations
52
  listNode(options?: ListOptions): Promise<{ body: V1NodeList }>;
53
  readNode(name: string, options?: ReadOptions): Promise<{ body: V1Node }>;
54
  patchNode(name: string, body: object, options?: PatchOptions): Promise<{ body: V1Node }>;
55
  replaceNode(name: string, body: V1Node, options?: ReplaceOptions): Promise<{ body: V1Node }>;
56
  deleteNode(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
57
  
58
  // PersistentVolume operations
59
  listPersistentVolume(options?: ListOptions): Promise<{ body: V1PersistentVolumeList }>;
60
  createPersistentVolume(body: V1PersistentVolume, options?: CreateOptions): Promise<{ body: V1PersistentVolume }>;
61
  readPersistentVolume(name: string, options?: ReadOptions): Promise<{ body: V1PersistentVolume }>;
62
  
63
  // PersistentVolumeClaim operations
64
  listNamespacedPersistentVolumeClaim(namespace: string, options?: ListOptions): Promise<{ body: V1PersistentVolumeClaimList }>;
65
  createNamespacedPersistentVolumeClaim(namespace: string, body: V1PersistentVolumeClaim, options?: CreateOptions): Promise<{ body: V1PersistentVolumeClaim }>;
66
}
67

68
/**
69
 * Application resources (deployments, replicasets, daemonsets, statefulsets)
70
 */
71
class AppsV1Api {
72
  // Deployment operations
73
  listNamespacedDeployment(namespace: string, options?: ListOptions): Promise<{ body: V1DeploymentList }>;
74
  createNamespacedDeployment(namespace: string, body: V1Deployment, options?: CreateOptions): Promise<{ body: V1Deployment }>;
75
  readNamespacedDeployment(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Deployment }>;
76
  replaceNamespacedDeployment(name: string, namespace: string, body: V1Deployment, options?: ReplaceOptions): Promise<{ body: V1Deployment }>;
77
  deleteNamespacedDeployment(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
78
  patchNamespacedDeployment(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1Deployment }>;
79
  
80
  // ReplicaSet operations
81
  listNamespacedReplicaSet(namespace: string, options?: ListOptions): Promise<{ body: V1ReplicaSetList }>;
82
  createNamespacedReplicaSet(namespace: string, body: V1ReplicaSet, options?: CreateOptions): Promise<{ body: V1ReplicaSet }>;
83
  readNamespacedReplicaSet(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1ReplicaSet }>;
84
  
85
  // DaemonSet operations
86
  listNamespacedDaemonSet(namespace: string, options?: ListOptions): Promise<{ body: V1DaemonSetList }>;
87
  createNamespacedDaemonSet(namespace: string, body: V1DaemonSet, options?: CreateOptions): Promise<{ body: V1DaemonSet }>;
88
  readNamespacedDaemonSet(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1DaemonSet }>;
89
  
90
  // StatefulSet operations
91
  listNamespacedStatefulSet(namespace: string, options?: ListOptions): Promise<{ body: V1StatefulSetList }>;
92
  createNamespacedStatefulSet(namespace: string, body: V1StatefulSet, options?: CreateOptions): Promise<{ body: V1StatefulSet }>;
93
  readNamespacedStatefulSet(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1StatefulSet }>;
94
}
95

96
/**
97
 * Batch resources (jobs, cronjobs)
98
 */
99
class BatchV1Api {
100
  // Job operations
101
  listNamespacedJob(namespace: string, options?: ListOptions): Promise<{ body: V1JobList }>;
102
  createNamespacedJob(namespace: string, body: V1Job, options?: CreateOptions): Promise<{ body: V1Job }>;
103
  readNamespacedJob(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Job }>;
104
  replaceNamespacedJob(name: string, namespace: string, body: V1Job, options?: ReplaceOptions): Promise<{ body: V1Job }>;
105
  deleteNamespacedJob(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
106
  
107
  // CronJob operations
108
  listNamespacedCronJob(namespace: string, options?: ListOptions): Promise<{ body: V1CronJobList }>;
109
  createNamespacedCronJob(namespace: string, body: V1CronJob, options?: CreateOptions): Promise<{ body: V1CronJob }>;
110
  readNamespacedCronJob(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1CronJob }>;
111
  replaceNamespacedCronJob(name: string, namespace: string, body: V1CronJob, options?: ReplaceOptions): Promise<{ body: V1CronJob }>;
112
  deleteNamespacedCronJob(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
113
}
114
```
115

116
### Extended API Clients
117

118
Additional API groups for specialized Kubernetes functionality.
119

120
```typescript { .api }
121
/**
122
 * Horizontal Pod Autoscaling
123
 */
124
class AutoscalingV1Api {
125
  listNamespacedHorizontalPodAutoscaler(namespace: string, options?: ListOptions): Promise<{ body: V1HorizontalPodAutoscalerList }>;
126
  createNamespacedHorizontalPodAutoscaler(namespace: string, body: V1HorizontalPodAutoscaler, options?: CreateOptions): Promise<{ body: V1HorizontalPodAutoscaler }>;
127
}
128

129
class AutoscalingV2Api {
130
  listNamespacedHorizontalPodAutoscaler(namespace: string, options?: ListOptions): Promise<{ body: V2HorizontalPodAutoscalerList }>;
131
  createNamespacedHorizontalPodAutoscaler(namespace: string, body: V2HorizontalPodAutoscaler, options?: CreateOptions): Promise<{ body: V2HorizontalPodAutoscaler }>;
132
}
133

134
/**
135
 * Networking resources (ingress, network policies)
136
 */
137
class NetworkingV1Api {
138
  listNamespacedIngress(namespace: string, options?: ListOptions): Promise<{ body: V1IngressList }>;
139
  createNamespacedIngress(namespace: string, body: V1Ingress, options?: CreateOptions): Promise<{ body: V1Ingress }>;
140
  listNamespacedNetworkPolicy(namespace: string, options?: ListOptions): Promise<{ body: V1NetworkPolicyList }>;
141
  createNamespacedNetworkPolicy(namespace: string, body: V1NetworkPolicy, options?: CreateOptions): Promise<{ body: V1NetworkPolicy }>;
142
}
143

144
/**
145
 * Role-Based Access Control
146
 */
147
class RbacAuthorizationV1Api {
148
  listClusterRole(options?: ListOptions): Promise<{ body: V1ClusterRoleList }>;
149
  createClusterRole(body: V1ClusterRole, options?: CreateOptions): Promise<{ body: V1ClusterRole }>;
150
  listClusterRoleBinding(options?: ListOptions): Promise<{ body: V1ClusterRoleBindingList }>;
151
  createClusterRoleBinding(body: V1ClusterRoleBinding, options?: CreateOptions): Promise<{ body: V1ClusterRoleBinding }>;
152
  listNamespacedRole(namespace: string, options?: ListOptions): Promise<{ body: V1RoleList }>;
153
  createNamespacedRole(namespace: string, body: V1Role, options?: CreateOptions): Promise<{ body: V1Role }>;
154
  listNamespacedRoleBinding(namespace: string, options?: ListOptions): Promise<{ body: V1RoleBindingList }>;
155
  createNamespacedRoleBinding(namespace: string, body: V1RoleBinding, options?: CreateOptions): Promise<{ body: V1RoleBinding }>;
156
}
157

158
/**
159
 * Custom Resource Definitions
160
 */
161
class ApiextensionsV1Api {
162
  listCustomResourceDefinition(options?: ListOptions): Promise<{ body: V1CustomResourceDefinitionList }>;
163
  createCustomResourceDefinition(body: V1CustomResourceDefinition, options?: CreateOptions): Promise<{ body: V1CustomResourceDefinition }>;
164
  readCustomResourceDefinition(name: string, options?: ReadOptions): Promise<{ body: V1CustomResourceDefinition }>;
165
}
166

167
/**
168
 * Custom Objects (for custom resources)
169
 */
170
class CustomObjectsApi {
171
  listClusterCustomObject(group: string, version: string, plural: string, options?: ListOptions): Promise<{ body: any }>;
172
  createClusterCustomObject(group: string, version: string, plural: string, body: object, options?: CreateOptions): Promise<{ body: any }>;
173
  getClusterCustomObject(group: string, version: string, plural: string, name: string, options?: ReadOptions): Promise<{ body: any }>;
174
  replaceClusterCustomObject(group: string, version: string, plural: string, name: string, body: object, options?: ReplaceOptions): Promise<{ body: any }>;
175
  deleteClusterCustomObject(group: string, version: string, plural: string, name: string, options?: DeleteOptions): Promise<{ body: any }>;
176
  
177
  listNamespacedCustomObject(group: string, version: string, namespace: string, plural: string, options?: ListOptions): Promise<{ body: any }>;
178
  createNamespacedCustomObject(group: string, version: string, namespace: string, plural: string, body: object, options?: CreateOptions): Promise<{ body: any }>;
179
  getNamespacedCustomObject(group: string, version: string, namespace: string, plural: string, name: string, options?: ReadOptions): Promise<{ body: any }>;
180
}
181

182
/**
183
 * Storage classes and volumes
184
 */
185
class StorageV1Api {
186
  listStorageClass(options?: ListOptions): Promise<{ body: V1StorageClassList }>;
187
  createStorageClass(body: V1StorageClass, options?: CreateOptions): Promise<{ body: V1StorageClass }>;
188
  readStorageClass(name: string, options?: ReadOptions): Promise<{ body: V1StorageClass }>;
189
  
190
  listVolumeAttachment(options?: ListOptions): Promise<{ body: V1VolumeAttachmentList }>;
191
  createVolumeAttachment(body: V1VolumeAttachment, options?: CreateOptions): Promise<{ body: V1VolumeAttachment }>;
192
}
193

194
/**
195
 * Certificate management and signing requests
196
 */
197
class CertificatesV1Api {
198
  listCertificateSigningRequest(options?: ListOptions): Promise<{ body: V1CertificateSigningRequestList }>;
199
  createCertificateSigningRequest(body: V1CertificateSigningRequest, options?: CreateOptions): Promise<{ body: V1CertificateSigningRequest }>;
200
  readCertificateSigningRequest(name: string, options?: ReadOptions): Promise<{ body: V1CertificateSigningRequest }>;
201
  replaceCertificateSigningRequest(name: string, body: V1CertificateSigningRequest, options?: ReplaceOptions): Promise<{ body: V1CertificateSigningRequest }>;
202
  deleteCertificateSigningRequest(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
203
  patchCertificateSigningRequest(name: string, body: object, options?: PatchOptions): Promise<{ body: V1CertificateSigningRequest }>;
204
  
205
  // Certificate signing request approval operations
206
  readCertificateSigningRequestApproval(name: string, options?: ReadOptions): Promise<{ body: V1CertificateSigningRequest }>;
207
  replaceCertificateSigningRequestApproval(name: string, body: V1CertificateSigningRequest, options?: ReplaceOptions): Promise<{ body: V1CertificateSigningRequest }>;
208
  patchCertificateSigningRequestApproval(name: string, body: object, options?: PatchOptions): Promise<{ body: V1CertificateSigningRequest }>;
209
}
210

211
/**
212
 * Leader election and coordination
213
 */
214
class CoordinationV1Api {
215
  listNamespacedLease(namespace: string, options?: ListOptions): Promise<{ body: V1LeaseList }>;
216
  createNamespacedLease(namespace: string, body: V1Lease, options?: CreateOptions): Promise<{ body: V1Lease }>;
217
  readNamespacedLease(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Lease }>;
218
  replaceNamespacedLease(name: string, namespace: string, body: V1Lease, options?: ReplaceOptions): Promise<{ body: V1Lease }>;
219
  deleteNamespacedLease(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
220
  patchNamespacedLease(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1Lease }>;
221
  
222
  listLeaseForAllNamespaces(options?: ListOptions): Promise<{ body: V1LeaseList }>;
223
}
224

225
/**
226
 * Service discovery and endpoint management
227
 */
228
class DiscoveryV1Api {
229
  listNamespacedEndpointSlice(namespace: string, options?: ListOptions): Promise<{ body: V1EndpointSliceList }>;
230
  createNamespacedEndpointSlice(namespace: string, body: V1EndpointSlice, options?: CreateOptions): Promise<{ body: V1EndpointSlice }>;
231
  readNamespacedEndpointSlice(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1EndpointSlice }>;
232
  replaceNamespacedEndpointSlice(name: string, namespace: string, body: V1EndpointSlice, options?: ReplaceOptions): Promise<{ body: V1EndpointSlice }>;
233
  deleteNamespacedEndpointSlice(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
234
  patchNamespacedEndpointSlice(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1EndpointSlice }>;
235
  
236
  listEndpointSliceForAllNamespaces(options?: ListOptions): Promise<{ body: V1EndpointSliceList }>;
237
}
238

239
/**
240
 * Events management (v1 API)
241
 */
242
class EventsV1Api {
243
  listNamespacedEvent(namespace: string, options?: ListOptions): Promise<{ body: V1EventList }>;
244
  createNamespacedEvent(namespace: string, body: V1Event, options?: CreateOptions): Promise<{ body: V1Event }>;
245
  readNamespacedEvent(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Event }>;
246
  replaceNamespacedEvent(name: string, namespace: string, body: V1Event, options?: ReplaceOptions): Promise<{ body: V1Event }>;
247
  deleteNamespacedEvent(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
248
  patchNamespacedEvent(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1Event }>;
249
  
250
  listEventForAllNamespaces(options?: ListOptions): Promise<{ body: V1EventList }>;
251
}
252

253
/**
254
 * Node runtime classes
255
 */
256
class NodeV1Api {
257
  listRuntimeClass(options?: ListOptions): Promise<{ body: V1RuntimeClassList }>;
258
  createRuntimeClass(body: V1RuntimeClass, options?: CreateOptions): Promise<{ body: V1RuntimeClass }>;
259
  readRuntimeClass(name: string, options?: ReadOptions): Promise<{ body: V1RuntimeClass }>;
260
  replaceRuntimeClass(name: string, body: V1RuntimeClass, options?: ReplaceOptions): Promise<{ body: V1RuntimeClass }>;
261
  deleteRuntimeClass(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
262
  patchRuntimeClass(name: string, body: object, options?: PatchOptions): Promise<{ body: V1RuntimeClass }>;
263
}
264

265
/**
266
 * Pod disruption budgets
267
 */
268
class PolicyV1Api {
269
  listNamespacedPodDisruptionBudget(namespace: string, options?: ListOptions): Promise<{ body: V1PodDisruptionBudgetList }>;
270
  createNamespacedPodDisruptionBudget(namespace: string, body: V1PodDisruptionBudget, options?: CreateOptions): Promise<{ body: V1PodDisruptionBudget }>;
271
  readNamespacedPodDisruptionBudget(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1PodDisruptionBudget }>;
272
  replaceNamespacedPodDisruptionBudget(name: string, namespace: string, body: V1PodDisruptionBudget, options?: ReplaceOptions): Promise<{ body: V1PodDisruptionBudget }>;
273
  deleteNamespacedPodDisruptionBudget(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
274
  patchNamespacedPodDisruptionBudget(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1PodDisruptionBudget }>;
275
  
276
  listPodDisruptionBudgetForAllNamespaces(options?: ListOptions): Promise<{ body: V1PodDisruptionBudgetList }>;
277
  
278
  // Status operations
279
  readNamespacedPodDisruptionBudgetStatus(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1PodDisruptionBudget }>;
280
  replaceNamespacedPodDisruptionBudgetStatus(name: string, namespace: string, body: V1PodDisruptionBudget, options?: ReplaceOptions): Promise<{ body: V1PodDisruptionBudget }>;
281
  patchNamespacedPodDisruptionBudgetStatus(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1PodDisruptionBudget }>;
282
}
283

284
/**
285
 * Priority classes for pod scheduling
286
 */
287
class SchedulingV1Api {
288
  listPriorityClass(options?: ListOptions): Promise<{ body: V1PriorityClassList }>;
289
  createPriorityClass(body: V1PriorityClass, options?: CreateOptions): Promise<{ body: V1PriorityClass }>;
290
  readPriorityClass(name: string, options?: ReadOptions): Promise<{ body: V1PriorityClass }>;
291
  replacePriorityClass(name: string, body: V1PriorityClass, options?: ReplaceOptions): Promise<{ body: V1PriorityClass }>;
292
  deletePriorityClass(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
293
  patchPriorityClass(name: string, body: object, options?: PatchOptions): Promise<{ body: V1PriorityClass }>;
294
}
295
```
296

297
### API Client Usage Patterns
298

299
**Creating API Clients:**
300

301
```typescript
302
import { KubeConfig, CoreV1Api, AppsV1Api } from '@kubernetes/client-node';
303

304
const kc = new KubeConfig();
305
kc.loadFromDefault();
306

307
// Create specific API clients
308
const coreApi = kc.makeApiClient(CoreV1Api);
309
const appsApi = kc.makeApiClient(AppsV1Api);
310
```
311

312
**Basic CRUD Operations:**
313

314
```typescript
315
// Create a pod
316
const pod: V1Pod = {
317
  metadata: {
318
    name: 'my-pod',
319
    namespace: 'default'
320
  },
321
  spec: {
322
    containers: [{
323
      name: 'my-container',
324
      image: 'nginx:latest'
325
    }]
326
  }
327
};
328

329
try {
330
  // Create
331
  const created = await coreApi.createNamespacedPod('default', pod);
332
  console.log('Pod created:', created.body.metadata?.name);
333
  
334
  // Read
335
  const retrieved = await coreApi.readNamespacedPod('my-pod', 'default');
336
  console.log('Pod status:', retrieved.body.status?.phase);
337
  
338
  // Update
339
  pod.spec!.containers[0].image = 'nginx:1.20';
340
  const updated = await coreApi.replaceNamespacedPod('my-pod', 'default', pod);
341
  
342
  // Patch
343
  const patch = { spec: { containers: [{ name: 'my-container', image: 'nginx:1.21' }] } };
344
  const patched = await coreApi.patchNamespacedPod('my-pod', 'default', patch);
345
  
346
  // Delete
347
  await coreApi.deleteNamespacedPod('my-pod', 'default');
348
  console.log('Pod deleted');
349
} catch (error) {
350
  console.error('API error:', error);
351
}
352
```
353

354
**List Operations with Filtering:**
355

356
```typescript
357
// List all pods in a namespace
358
const allPods = await coreApi.listNamespacedPod('default');
359
console.log('Pod count:', allPods.body.items.length);
360

361
// List with label selector
362
const labelSelector = 'app=web,version=v1';
363
const filteredPods = await coreApi.listNamespacedPod('default', {
364
  labelSelector
365
});
366

367
// List with field selector
368
const fieldSelector = 'status.phase=Running';
369
const runningPods = await coreApi.listNamespacedPod('default', {
370
  fieldSelector
371
});
372

373
// List with pagination
374
const pageSize = 10;
375
const firstPage = await coreApi.listNamespacedPod('default', {
376
  limit: pageSize
377
});
378

379
if (firstPage.body.metadata?.continue) {
380
  const nextPage = await coreApi.listNamespacedPod('default', {
381
    limit: pageSize,
382
    continue: firstPage.body.metadata.continue
383
  });
384
}
385
```
386

387
**Working with Custom Resources:**
388

389
```typescript
390
import { CustomObjectsApi } from '@kubernetes/client-node';
391

392
const customApi = kc.makeApiClient(CustomObjectsApi);
393

394
// Create a custom resource
395
const customResource = {
396
  apiVersion: 'myapp.example.com/v1',
397
  kind: 'MyResource',
398
  metadata: {
399
    name: 'my-custom-resource',
400
    namespace: 'default'
401
  },
402
  spec: {
403
    replicas: 3,
404
    image: 'my-app:latest'
405
  }
406
};
407

408
const created = await customApi.createNamespacedCustomObject(
409
  'myapp.example.com',
410
  'v1',
411
  'default',
412
  'myresources',
413
  customResource
414
);
415
```
416

417
### Common Options
418

419
```typescript { .api }
420
interface ListOptions {
421
  /** Label selector for filtering resources */
422
  labelSelector?: string;
423
  /** Field selector for filtering resources */
424
  fieldSelector?: string;
425
  /** Maximum number of items to return */
426
  limit?: number;
427
  /** Continue token for pagination */
428
  continue?: string;
429
  /** Resource version for watch operations */
430
  resourceVersion?: string;
431
  /** Timeout for the list operation */
432
  timeoutSeconds?: number;
433
  /** Watch for changes instead of listing */
434
  watch?: boolean;
435
}
436

437
interface CreateOptions {
438
  /** Pretty-print the output */
439
  pretty?: string;
440
  /** Dry run mode ('All' or 'Server') */
441
  dryRun?: string;
442
  /** Field manager name for server-side apply */
443
  fieldManager?: string;
444
  /** Field validation ('Strict', 'Warn', or 'Ignore') */
445
  fieldValidation?: string;
446
}
447

448
interface DeleteOptions {
449
  /** Grace period in seconds */
450
  gracePeriodSeconds?: number;
451
  /** Whether to orphan dependents */
452
  orphanDependents?: boolean;
453
  /** Propagation policy ('Foreground', 'Background', or 'Orphan') */
454
  propagationPolicy?: string;
455
  /** Preconditions for deletion */
456
  preconditions?: V1Preconditions;
457
}
458

459
interface PatchOptions {
460
  /** Patch strategy (JSON Patch, Merge Patch, Strategic Merge Patch) */
461
  contentType?: string;
462
  /** Pretty-print the output */
463
  pretty?: string;
464
  /** Dry run mode */
465
  dryRun?: string;
466
  /** Field manager name */
467
  fieldManager?: string;
468
  /** Force the patch */
469
  force?: boolean;
470
}
471
```
472

473
### Error Handling
474

475
All API client methods return promises that can reject with detailed error information:
476

477
```typescript
478
import { ApiException } from '@kubernetes/client-node';
479

480
try {
481
  const pod = await coreApi.readNamespacedPod('nonexistent', 'default');
482
} catch (error) {
483
  if (error instanceof ApiException) {
484
    console.error('API Error:', error.code, error.message);
485
    console.error('Response body:', error.body);
486
  } else {
487
    console.error('Network error:', error.message);
488
  }
489
}
490
```