Generated API Clients

/**
 * Core Kubernetes resources (pods, services, configmaps, etc.)
 */
class CoreV1Api {
  // Pod operations
  listNamespacedPod(namespace: string, options?: ListOptions): Promise<{ body: V1PodList }>;
  createNamespacedPod(namespace: string, body: V1Pod, options?: CreateOptions): Promise<{ body: V1Pod }>;
  readNamespacedPod(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Pod }>;
  replaceNamespacedPod(name: string, namespace: string, body: V1Pod, options?: ReplaceOptions): Promise<{ body: V1Pod }>;
  deleteNamespacedPod(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchNamespacedPod(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1Pod }>;
  
  // Service operations
  listNamespacedService(namespace: string, options?: ListOptions): Promise<{ body: V1ServiceList }>;
  createNamespacedService(namespace: string, body: V1Service, options?: CreateOptions): Promise<{ body: V1Service }>;
  readNamespacedService(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Service }>;
  replaceNamespacedService(name: string, namespace: string, body: V1Service, options?: ReplaceOptions): Promise<{ body: V1Service }>;
  deleteNamespacedService(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  
  // ConfigMap operations
  listNamespacedConfigMap(namespace: string, options?: ListOptions): Promise<{ body: V1ConfigMapList }>;
  createNamespacedConfigMap(namespace: string, body: V1ConfigMap, options?: CreateOptions): Promise<{ body: V1ConfigMap }>;
  readNamespacedConfigMap(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1ConfigMap }>;
  replaceNamespacedConfigMap(name: string, namespace: string, body: V1ConfigMap, options?: ReplaceOptions): Promise<{ body: V1ConfigMap }>;
  deleteNamespacedConfigMap(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  
  // Secret operations
  listNamespacedSecret(namespace: string, options?: ListOptions): Promise<{ body: V1SecretList }>;
  createNamespacedSecret(namespace: string, body: V1Secret, options?: CreateOptions): Promise<{ body: V1Secret }>;
  readNamespacedSecret(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Secret }>;
  replaceNamespacedSecret(name: string, namespace: string, body: V1Secret, options?: ReplaceOptions): Promise<{ body: V1Secret }>;
  deleteNamespacedSecret(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  
  // Namespace operations
  listNamespace(options?: ListOptions): Promise<{ body: V1NamespaceList }>;
  createNamespace(body: V1Namespace, options?: CreateOptions): Promise<{ body: V1Namespace }>;
  readNamespace(name: string, options?: ReadOptions): Promise<{ body: V1Namespace }>;
  replaceNamespace(name: string, body: V1Namespace, options?: ReplaceOptions): Promise<{ body: V1Namespace }>;
  deleteNamespace(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  
  // Node operations
  listNode(options?: ListOptions): Promise<{ body: V1NodeList }>;
  readNode(name: string, options?: ReadOptions): Promise<{ body: V1Node }>;
  patchNode(name: string, body: object, options?: PatchOptions): Promise<{ body: V1Node }>;
  replaceNode(name: string, body: V1Node, options?: ReplaceOptions): Promise<{ body: V1Node }>;
  deleteNode(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  
  // PersistentVolume operations
  listPersistentVolume(options?: ListOptions): Promise<{ body: V1PersistentVolumeList }>;
  createPersistentVolume(body: V1PersistentVolume, options?: CreateOptions): Promise<{ body: V1PersistentVolume }>;
  readPersistentVolume(name: string, options?: ReadOptions): Promise<{ body: V1PersistentVolume }>;
  
  // PersistentVolumeClaim operations
  listNamespacedPersistentVolumeClaim(namespace: string, options?: ListOptions): Promise<{ body: V1PersistentVolumeClaimList }>;
  createNamespacedPersistentVolumeClaim(namespace: string, body: V1PersistentVolumeClaim, options?: CreateOptions): Promise<{ body: V1PersistentVolumeClaim }>;
}

/**
 * Application resources (deployments, replicasets, daemonsets, statefulsets)
 */
class AppsV1Api {
  // Deployment operations
  listNamespacedDeployment(namespace: string, options?: ListOptions): Promise<{ body: V1DeploymentList }>;
  createNamespacedDeployment(namespace: string, body: V1Deployment, options?: CreateOptions): Promise<{ body: V1Deployment }>;
  readNamespacedDeployment(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Deployment }>;
  replaceNamespacedDeployment(name: string, namespace: string, body: V1Deployment, options?: ReplaceOptions): Promise<{ body: V1Deployment }>;
  deleteNamespacedDeployment(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchNamespacedDeployment(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1Deployment }>;
  
  // ReplicaSet operations
  listNamespacedReplicaSet(namespace: string, options?: ListOptions): Promise<{ body: V1ReplicaSetList }>;
  createNamespacedReplicaSet(namespace: string, body: V1ReplicaSet, options?: CreateOptions): Promise<{ body: V1ReplicaSet }>;
  readNamespacedReplicaSet(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1ReplicaSet }>;
  
  // DaemonSet operations
  listNamespacedDaemonSet(namespace: string, options?: ListOptions): Promise<{ body: V1DaemonSetList }>;
  createNamespacedDaemonSet(namespace: string, body: V1DaemonSet, options?: CreateOptions): Promise<{ body: V1DaemonSet }>;
  readNamespacedDaemonSet(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1DaemonSet }>;
  
  // StatefulSet operations
  listNamespacedStatefulSet(namespace: string, options?: ListOptions): Promise<{ body: V1StatefulSetList }>;
  createNamespacedStatefulSet(namespace: string, body: V1StatefulSet, options?: CreateOptions): Promise<{ body: V1StatefulSet }>;
  readNamespacedStatefulSet(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1StatefulSet }>;
}

/**
 * Batch resources (jobs, cronjobs)
 */
class BatchV1Api {
  // Job operations
  listNamespacedJob(namespace: string, options?: ListOptions): Promise<{ body: V1JobList }>;
  createNamespacedJob(namespace: string, body: V1Job, options?: CreateOptions): Promise<{ body: V1Job }>;
  readNamespacedJob(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Job }>;
  replaceNamespacedJob(name: string, namespace: string, body: V1Job, options?: ReplaceOptions): Promise<{ body: V1Job }>;
  deleteNamespacedJob(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  
  // CronJob operations
  listNamespacedCronJob(namespace: string, options?: ListOptions): Promise<{ body: V1CronJobList }>;
  createNamespacedCronJob(namespace: string, body: V1CronJob, options?: CreateOptions): Promise<{ body: V1CronJob }>;
  readNamespacedCronJob(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1CronJob }>;
  replaceNamespacedCronJob(name: string, namespace: string, body: V1CronJob, options?: ReplaceOptions): Promise<{ body: V1CronJob }>;
  deleteNamespacedCronJob(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
}

/**
 * Horizontal Pod Autoscaling
 */
class AutoscalingV1Api {
  listNamespacedHorizontalPodAutoscaler(namespace: string, options?: ListOptions): Promise<{ body: V1HorizontalPodAutoscalerList }>;
  createNamespacedHorizontalPodAutoscaler(namespace: string, body: V1HorizontalPodAutoscaler, options?: CreateOptions): Promise<{ body: V1HorizontalPodAutoscaler }>;
}

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

/**
 * Networking resources (ingress, network policies)
 */
class NetworkingV1Api {
  listNamespacedIngress(namespace: string, options?: ListOptions): Promise<{ body: V1IngressList }>;
  createNamespacedIngress(namespace: string, body: V1Ingress, options?: CreateOptions): Promise<{ body: V1Ingress }>;
  listNamespacedNetworkPolicy(namespace: string, options?: ListOptions): Promise<{ body: V1NetworkPolicyList }>;
  createNamespacedNetworkPolicy(namespace: string, body: V1NetworkPolicy, options?: CreateOptions): Promise<{ body: V1NetworkPolicy }>;
}

/**
 * Role-Based Access Control
 */
class RbacAuthorizationV1Api {
  listClusterRole(options?: ListOptions): Promise<{ body: V1ClusterRoleList }>;
  createClusterRole(body: V1ClusterRole, options?: CreateOptions): Promise<{ body: V1ClusterRole }>;
  listClusterRoleBinding(options?: ListOptions): Promise<{ body: V1ClusterRoleBindingList }>;
  createClusterRoleBinding(body: V1ClusterRoleBinding, options?: CreateOptions): Promise<{ body: V1ClusterRoleBinding }>;
  listNamespacedRole(namespace: string, options?: ListOptions): Promise<{ body: V1RoleList }>;
  createNamespacedRole(namespace: string, body: V1Role, options?: CreateOptions): Promise<{ body: V1Role }>;
  listNamespacedRoleBinding(namespace: string, options?: ListOptions): Promise<{ body: V1RoleBindingList }>;
  createNamespacedRoleBinding(namespace: string, body: V1RoleBinding, options?: CreateOptions): Promise<{ body: V1RoleBinding }>;
}

/**
 * Custom Resource Definitions
 */
class ApiextensionsV1Api {
  listCustomResourceDefinition(options?: ListOptions): Promise<{ body: V1CustomResourceDefinitionList }>;
  createCustomResourceDefinition(body: V1CustomResourceDefinition, options?: CreateOptions): Promise<{ body: V1CustomResourceDefinition }>;
  readCustomResourceDefinition(name: string, options?: ReadOptions): Promise<{ body: V1CustomResourceDefinition }>;
}

/**
 * Custom Objects (for custom resources)
 */
class CustomObjectsApi {
  listClusterCustomObject(group: string, version: string, plural: string, options?: ListOptions): Promise<{ body: any }>;
  createClusterCustomObject(group: string, version: string, plural: string, body: object, options?: CreateOptions): Promise<{ body: any }>;
  getClusterCustomObject(group: string, version: string, plural: string, name: string, options?: ReadOptions): Promise<{ body: any }>;
  replaceClusterCustomObject(group: string, version: string, plural: string, name: string, body: object, options?: ReplaceOptions): Promise<{ body: any }>;
  deleteClusterCustomObject(group: string, version: string, plural: string, name: string, options?: DeleteOptions): Promise<{ body: any }>;
  
  listNamespacedCustomObject(group: string, version: string, namespace: string, plural: string, options?: ListOptions): Promise<{ body: any }>;
  createNamespacedCustomObject(group: string, version: string, namespace: string, plural: string, body: object, options?: CreateOptions): Promise<{ body: any }>;
  getNamespacedCustomObject(group: string, version: string, namespace: string, plural: string, name: string, options?: ReadOptions): Promise<{ body: any }>;
}

/**
 * Storage classes and volumes
 */
class StorageV1Api {
  listStorageClass(options?: ListOptions): Promise<{ body: V1StorageClassList }>;
  createStorageClass(body: V1StorageClass, options?: CreateOptions): Promise<{ body: V1StorageClass }>;
  readStorageClass(name: string, options?: ReadOptions): Promise<{ body: V1StorageClass }>;
  
  listVolumeAttachment(options?: ListOptions): Promise<{ body: V1VolumeAttachmentList }>;
  createVolumeAttachment(body: V1VolumeAttachment, options?: CreateOptions): Promise<{ body: V1VolumeAttachment }>;
}

/**
 * Certificate management and signing requests
 */
class CertificatesV1Api {
  listCertificateSigningRequest(options?: ListOptions): Promise<{ body: V1CertificateSigningRequestList }>;
  createCertificateSigningRequest(body: V1CertificateSigningRequest, options?: CreateOptions): Promise<{ body: V1CertificateSigningRequest }>;
  readCertificateSigningRequest(name: string, options?: ReadOptions): Promise<{ body: V1CertificateSigningRequest }>;
  replaceCertificateSigningRequest(name: string, body: V1CertificateSigningRequest, options?: ReplaceOptions): Promise<{ body: V1CertificateSigningRequest }>;
  deleteCertificateSigningRequest(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchCertificateSigningRequest(name: string, body: object, options?: PatchOptions): Promise<{ body: V1CertificateSigningRequest }>;
  
  // Certificate signing request approval operations
  readCertificateSigningRequestApproval(name: string, options?: ReadOptions): Promise<{ body: V1CertificateSigningRequest }>;
  replaceCertificateSigningRequestApproval(name: string, body: V1CertificateSigningRequest, options?: ReplaceOptions): Promise<{ body: V1CertificateSigningRequest }>;
  patchCertificateSigningRequestApproval(name: string, body: object, options?: PatchOptions): Promise<{ body: V1CertificateSigningRequest }>;
}

/**
 * Leader election and coordination
 */
class CoordinationV1Api {
  listNamespacedLease(namespace: string, options?: ListOptions): Promise<{ body: V1LeaseList }>;
  createNamespacedLease(namespace: string, body: V1Lease, options?: CreateOptions): Promise<{ body: V1Lease }>;
  readNamespacedLease(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Lease }>;
  replaceNamespacedLease(name: string, namespace: string, body: V1Lease, options?: ReplaceOptions): Promise<{ body: V1Lease }>;
  deleteNamespacedLease(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchNamespacedLease(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1Lease }>;
  
  listLeaseForAllNamespaces(options?: ListOptions): Promise<{ body: V1LeaseList }>;
}

/**
 * Service discovery and endpoint management
 */
class DiscoveryV1Api {
  listNamespacedEndpointSlice(namespace: string, options?: ListOptions): Promise<{ body: V1EndpointSliceList }>;
  createNamespacedEndpointSlice(namespace: string, body: V1EndpointSlice, options?: CreateOptions): Promise<{ body: V1EndpointSlice }>;
  readNamespacedEndpointSlice(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1EndpointSlice }>;
  replaceNamespacedEndpointSlice(name: string, namespace: string, body: V1EndpointSlice, options?: ReplaceOptions): Promise<{ body: V1EndpointSlice }>;
  deleteNamespacedEndpointSlice(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchNamespacedEndpointSlice(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1EndpointSlice }>;
  
  listEndpointSliceForAllNamespaces(options?: ListOptions): Promise<{ body: V1EndpointSliceList }>;
}

/**
 * Events management (v1 API)
 */
class EventsV1Api {
  listNamespacedEvent(namespace: string, options?: ListOptions): Promise<{ body: V1EventList }>;
  createNamespacedEvent(namespace: string, body: V1Event, options?: CreateOptions): Promise<{ body: V1Event }>;
  readNamespacedEvent(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1Event }>;
  replaceNamespacedEvent(name: string, namespace: string, body: V1Event, options?: ReplaceOptions): Promise<{ body: V1Event }>;
  deleteNamespacedEvent(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchNamespacedEvent(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1Event }>;
  
  listEventForAllNamespaces(options?: ListOptions): Promise<{ body: V1EventList }>;
}

/**
 * Node runtime classes
 */
class NodeV1Api {
  listRuntimeClass(options?: ListOptions): Promise<{ body: V1RuntimeClassList }>;
  createRuntimeClass(body: V1RuntimeClass, options?: CreateOptions): Promise<{ body: V1RuntimeClass }>;
  readRuntimeClass(name: string, options?: ReadOptions): Promise<{ body: V1RuntimeClass }>;
  replaceRuntimeClass(name: string, body: V1RuntimeClass, options?: ReplaceOptions): Promise<{ body: V1RuntimeClass }>;
  deleteRuntimeClass(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchRuntimeClass(name: string, body: object, options?: PatchOptions): Promise<{ body: V1RuntimeClass }>;
}

/**
 * Pod disruption budgets
 */
class PolicyV1Api {
  listNamespacedPodDisruptionBudget(namespace: string, options?: ListOptions): Promise<{ body: V1PodDisruptionBudgetList }>;
  createNamespacedPodDisruptionBudget(namespace: string, body: V1PodDisruptionBudget, options?: CreateOptions): Promise<{ body: V1PodDisruptionBudget }>;
  readNamespacedPodDisruptionBudget(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1PodDisruptionBudget }>;
  replaceNamespacedPodDisruptionBudget(name: string, namespace: string, body: V1PodDisruptionBudget, options?: ReplaceOptions): Promise<{ body: V1PodDisruptionBudget }>;
  deleteNamespacedPodDisruptionBudget(name: string, namespace: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchNamespacedPodDisruptionBudget(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1PodDisruptionBudget }>;
  
  listPodDisruptionBudgetForAllNamespaces(options?: ListOptions): Promise<{ body: V1PodDisruptionBudgetList }>;
  
  // Status operations
  readNamespacedPodDisruptionBudgetStatus(name: string, namespace: string, options?: ReadOptions): Promise<{ body: V1PodDisruptionBudget }>;
  replaceNamespacedPodDisruptionBudgetStatus(name: string, namespace: string, body: V1PodDisruptionBudget, options?: ReplaceOptions): Promise<{ body: V1PodDisruptionBudget }>;
  patchNamespacedPodDisruptionBudgetStatus(name: string, namespace: string, body: object, options?: PatchOptions): Promise<{ body: V1PodDisruptionBudget }>;
}

/**
 * Priority classes for pod scheduling
 */
class SchedulingV1Api {
  listPriorityClass(options?: ListOptions): Promise<{ body: V1PriorityClassList }>;
  createPriorityClass(body: V1PriorityClass, options?: CreateOptions): Promise<{ body: V1PriorityClass }>;
  readPriorityClass(name: string, options?: ReadOptions): Promise<{ body: V1PriorityClass }>;
  replacePriorityClass(name: string, body: V1PriorityClass, options?: ReplaceOptions): Promise<{ body: V1PriorityClass }>;
  deletePriorityClass(name: string, options?: DeleteOptions): Promise<{ body: V1Status }>;
  patchPriorityClass(name: string, body: object, options?: PatchOptions): Promise<{ body: V1PriorityClass }>;
}

import { KubeConfig, CoreV1Api, AppsV1Api } from '@kubernetes/client-node';

const kc = new KubeConfig();
kc.loadFromDefault();

// Create specific API clients
const coreApi = kc.makeApiClient(CoreV1Api);
const appsApi = kc.makeApiClient(AppsV1Api);

// Create a pod
const pod: V1Pod = {
  metadata: {
    name: 'my-pod',
    namespace: 'default'
  },
  spec: {
    containers: [{
      name: 'my-container',
      image: 'nginx:latest'
    }]
  }
};

try {
  // Create
  const created = await coreApi.createNamespacedPod('default', pod);
  console.log('Pod created:', created.body.metadata?.name);
  
  // Read
  const retrieved = await coreApi.readNamespacedPod('my-pod', 'default');
  console.log('Pod status:', retrieved.body.status?.phase);
  
  // Update
  pod.spec!.containers[0].image = 'nginx:1.20';
  const updated = await coreApi.replaceNamespacedPod('my-pod', 'default', pod);
  
  // Patch
  const patch = { spec: { containers: [{ name: 'my-container', image: 'nginx:1.21' }] } };
  const patched = await coreApi.patchNamespacedPod('my-pod', 'default', patch);
  
  // Delete
  await coreApi.deleteNamespacedPod('my-pod', 'default');
  console.log('Pod deleted');
} catch (error) {
  console.error('API error:', error);
}

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

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

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

// List with pagination
const pageSize = 10;
const firstPage = await coreApi.listNamespacedPod('default', {
  limit: pageSize
});

if (firstPage.body.metadata?.continue) {
  const nextPage = await coreApi.listNamespacedPod('default', {
    limit: pageSize,
    continue: firstPage.body.metadata.continue
  });
}

import { CustomObjectsApi } from '@kubernetes/client-node';

const customApi = kc.makeApiClient(CustomObjectsApi);

// Create a custom resource
const customResource = {
  apiVersion: 'myapp.example.com/v1',
  kind: 'MyResource',
  metadata: {
    name: 'my-custom-resource',
    namespace: 'default'
  },
  spec: {
    replicas: 3,
    image: 'my-app:latest'
  }
};

const created = await customApi.createNamespacedCustomObject(
  'myapp.example.com',
  'v1',
  'default',
  'myresources',
  customResource
);

interface ListOptions {
  /** Label selector for filtering resources */
  labelSelector?: string;
  /** Field selector for filtering resources */
  fieldSelector?: string;
  /** Maximum number of items to return */
  limit?: number;
  /** Continue token for pagination */
  continue?: string;
  /** Resource version for watch operations */
  resourceVersion?: string;
  /** Timeout for the list operation */
  timeoutSeconds?: number;
  /** Watch for changes instead of listing */
  watch?: boolean;
}

interface CreateOptions {
  /** Pretty-print the output */
  pretty?: string;
  /** Dry run mode ('All' or 'Server') */
  dryRun?: string;
  /** Field manager name for server-side apply */
  fieldManager?: string;
  /** Field validation ('Strict', 'Warn', or 'Ignore') */
  fieldValidation?: string;
}

interface DeleteOptions {
  /** Grace period in seconds */
  gracePeriodSeconds?: number;
  /** Whether to orphan dependents */
  orphanDependents?: boolean;
  /** Propagation policy ('Foreground', 'Background', or 'Orphan') */
  propagationPolicy?: string;
  /** Preconditions for deletion */
  preconditions?: V1Preconditions;
}

interface PatchOptions {
  /** Patch strategy (JSON Patch, Merge Patch, Strategic Merge Patch) */
  contentType?: string;
  /** Pretty-print the output */
  pretty?: string;
  /** Dry run mode */
  dryRun?: string;
  /** Field manager name */
  fieldManager?: string;
  /** Force the patch */
  force?: boolean;
}

import { ApiException } from '@kubernetes/client-node';

try {
  const pod = await coreApi.readNamespacedPod('nonexistent', 'default');
} catch (error) {
  if (error instanceof ApiException) {
    console.error('API Error:', error.code, error.message);
    console.error('Response body:', error.body);
  } else {
    console.error('Network error:', error.message);
  }
}