@arizeai/phoenix-client/src/__generated__/api/v1.d.ts

A client for the Phoenix API

/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
  "/v1/datasets": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** List datasets */
    get: operations["listDatasets"];
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/datasets/{id}": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** Get dataset by ID */
    get: operations["getDataset"];
    put?: never;
    post?: never;
    /** Delete dataset by ID */
    delete: operations["deleteDatasetById"];
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/datasets/{id}/versions": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** List dataset versions */
    get: operations["listDatasetVersionsByDatasetId"];
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/datasets/upload": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    /** Upload dataset from JSON, CSV, or PyArrow */
    post: operations["uploadDataset"];
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/datasets/{id}/examples": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** Get examples from a dataset */
    get: operations["getDatasetExamples"];
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/datasets/{id}/csv": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** Download dataset examples as CSV file */
    get: operations["getDatasetCsv"];
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/datasets/{id}/jsonl/openai_ft": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** Download dataset examples as OpenAI fine-tuning JSONL file */
    get: operations["getDatasetJSONLOpenAIFineTuning"];
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/datasets/{id}/jsonl/openai_evals": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** Download dataset examples as OpenAI evals JSONL file */
    get: operations["getDatasetJSONLOpenAIEvals"];
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/datasets/{dataset_id}/experiments": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** List experiments by dataset */
    get: operations["listExperiments"];
    put?: never;
    /** Create experiment on a dataset */
    post: operations["createExperiment"];
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/experiments/{experiment_id}": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** Get experiment by ID */
    get: operations["getExperiment"];
    put?: never;
    post?: never;
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/span_annotations": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    get?: never;
    put?: never;
    /** Create or update span annotations */
    post: operations["annotateSpans"];
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
  "/v1/evaluations": {
    parameters: {
      query?: never;
      header?: never;
      path?: never;
      cookie?: never;
    };
    /** Get span, trace, or document evaluations from a project */
    get: operations["getEvaluations"];
    put?: never;
    /** Add span, trace, or document evaluations */
    post: operations["addEvaluations"];
    delete?: never;
    options?: never;
    head?: never;
    patch?: never;
    trace?: never;
  };
}
export type webhooks = Record<string, never>;
export interface components {
  schemas: {
    /** AnnotateSpansRequestBody */
    AnnotateSpansRequestBody: {
      /** Data */
      data: components["schemas"]["SpanAnnotation"][];
    };
    /** AnnotateSpansResponseBody */
    AnnotateSpansResponseBody: {
      /** Data */
      data: components["schemas"]["InsertedSpanAnnotation"][];
    };
    /**
     * CreateExperimentRequestBody
     * @description Details of the experiment to be created
     */
    CreateExperimentRequestBody: {
      /**
       * Name
       * @description Name of the experiment (if omitted, a random name will be generated)
       */
      name?: string | null;
      /**
       * Description
       * @description An optional description of the experiment
       */
      description?: string | null;
      /**
       * Metadata
       * @description Metadata for the experiment
       */
      metadata?: Record<string, never> | null;
      /**
       * Version Id
       * @description ID of the dataset version over which the experiment will be run (if omitted, the latest version will be used)
       */
      version_id?: string | null;
      /**
       * Repetitions
       * @description Number of times the experiment should be repeated for each example
       * @default 1
       */
      repetitions: number;
    };
    /** CreateExperimentResponseBody */
    CreateExperimentResponseBody: {
      data: components["schemas"]["Experiment"];
    };
    /** Dataset */
    Dataset: {
      /** Id */
      id: string;
      /** Name */
      name: string;
      /** Description */
      description: string | null;
      /** Metadata */
      metadata: Record<string, never>;
      /**
       * Created At
       * Format: date-time
       */
      created_at: string;
      /**
       * Updated At
       * Format: date-time
       */
      updated_at: string;
    };
    /** DatasetExample */
    DatasetExample: {
      /** Id */
      id: string;
      /** Input */
      input: Record<string, never>;
      /** Output */
      output: Record<string, never>;
      /** Metadata */
      metadata: Record<string, never>;
      /**
       * Updated At
       * Format: date-time
       */
      updated_at: string;
    };
    /** DatasetVersion */
    DatasetVersion: {
      /** Version Id */
      version_id: string;
      /** Description */
      description: string | null;
      /** Metadata */
      metadata: Record<string, never>;
      /**
       * Created At
       * Format: date-time
       */
      created_at: string;
    };
    /** DatasetWithExampleCount */
    DatasetWithExampleCount: {
      /** Id */
      id: string;
      /** Name */
      name: string;
      /** Description */
      description: string | null;
      /** Metadata */
      metadata: Record<string, never>;
      /**
       * Created At
       * Format: date-time
       */
      created_at: string;
      /**
       * Updated At
       * Format: date-time
       */
      updated_at: string;
      /** Example Count */
      example_count: number;
    };
    /** Experiment */
    Experiment: {
      /**
       * Id
       * @description The ID of the experiment
       */
      id: string;
      /**
       * Dataset Id
       * @description The ID of the dataset associated with the experiment
       */
      dataset_id: string;
      /**
       * Dataset Version Id
       * @description The ID of the dataset version associated with the experiment
       */
      dataset_version_id: string;
      /**
       * Repetitions
       * @description Number of times the experiment is repeated
       */
      repetitions: number;
      /**
       * Metadata
       * @description Metadata of the experiment
       */
      metadata: Record<string, never>;
      /**
       * Project Name
       * @description The name of the project associated with the experiment
       */
      project_name: string | null;
      /**
       * Created At
       * Format: date-time
       * @description The creation timestamp of the experiment
       */
      created_at: string;
      /**
       * Updated At
       * Format: date-time
       * @description The last update timestamp of the experiment
       */
      updated_at: string;
    };
    /** GetDatasetResponseBody */
    GetDatasetResponseBody: {
      data: components["schemas"]["DatasetWithExampleCount"];
    };
    /** GetExperimentResponseBody */
    GetExperimentResponseBody: {
      data: components["schemas"]["Experiment"];
    };
    /** HTTPValidationError */
    HTTPValidationError: {
      /** Detail */
      detail?: components["schemas"]["ValidationError"][];
    };
    /** InsertedSpanAnnotation */
    InsertedSpanAnnotation: {
      /**
       * Id
       * @description The ID of the inserted span annotation
       */
      id: string;
    };
    /** ListDatasetExamplesData */
    ListDatasetExamplesData: {
      /** Dataset Id */
      dataset_id: string;
      /** Version Id */
      version_id: string;
      /** Examples */
      examples: components["schemas"]["DatasetExample"][];
    };
    /** ListDatasetExamplesResponseBody */
    ListDatasetExamplesResponseBody: {
      data: components["schemas"]["ListDatasetExamplesData"];
    };
    /** ListDatasetVersionsResponseBody */
    ListDatasetVersionsResponseBody: {
      /** Data */
      data: components["schemas"]["DatasetVersion"][];
      /** Next Cursor */
      next_cursor: string | null;
    };
    /** ListDatasetsResponseBody */
    ListDatasetsResponseBody: {
      /** Data */
      data: components["schemas"]["Dataset"][];
      /** Next Cursor */
      next_cursor: string | null;
    };
    /** ListExperimentsResponseBody */
    ListExperimentsResponseBody: {
      /** Data */
      data: components["schemas"]["Experiment"][];
    };
    /** SpanAnnotation */
    SpanAnnotation: {
      /**
       * Span Id
       * @description OpenTelemetry Span ID (hex format w/o 0x prefix)
       */
      span_id: string;
      /**
       * Name
       * @description The name of the annotation
       */
      name: string;
      /**
       * Annotator Kind
       * @description The kind of annotator used for the annotation
       * @enum {string}
       */
      annotator_kind: "LLM" | "HUMAN";
      /** @description The result of the annotation */
      result?: components["schemas"]["SpanAnnotationResult"] | null;
      /**
       * Metadata
       * @description Metadata for the annotation
       */
      metadata?: Record<string, never> | null;
    };
    /** SpanAnnotationResult */
    SpanAnnotationResult: {
      /**
       * Label
       * @description The label assigned by the annotation
       */
      label?: string | null;
      /**
       * Score
       * @description The score assigned by the annotation
       */
      score?: number | null;
      /**
       * Explanation
       * @description Explanation of the annotation result
       */
      explanation?: string | null;
    };
    /** UploadDatasetData */
    UploadDatasetData: {
      /** Dataset Id */
      dataset_id: string;
    };
    /** UploadDatasetResponseBody */
    UploadDatasetResponseBody: {
      data: components["schemas"]["UploadDatasetData"];
    };
    /** ValidationError */
    ValidationError: {
      /** Location */
      loc: (string | number)[];
      /** Message */
      msg: string;
      /** Error Type */
      type: string;
    };
  };
  responses: never;
  parameters: never;
  requestBodies: never;
  headers: never;
  pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
  listDatasets: {
    parameters: {
      query?: {
        /** @description Cursor for pagination */
        cursor?: string | null;
        /** @description An optional dataset name to filter by */
        name?: string | null;
        /** @description The max number of datasets to return at a time. */
        limit?: number;
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["ListDatasetsResponseBody"];
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Unprocessable Entity */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
    };
  };
  getDataset: {
    parameters: {
      query?: never;
      header?: never;
      path: {
        /** @description The ID of the dataset */
        id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["GetDatasetResponseBody"];
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Not Found */
      404: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Validation Error */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["HTTPValidationError"];
        };
      };
    };
  };
  deleteDatasetById: {
    parameters: {
      query?: never;
      header?: never;
      path: {
        /** @description The ID of the dataset to delete. */
        id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      204: {
        headers: {
          [name: string]: unknown;
        };
        content?: never;
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Dataset not found */
      404: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Invalid dataset ID */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
    };
  };
  listDatasetVersionsByDatasetId: {
    parameters: {
      query?: {
        /** @description Cursor for pagination */
        cursor?: string | null;
        /** @description The max number of dataset versions to return at a time */
        limit?: number;
      };
      header?: never;
      path: {
        /** @description The ID of the dataset */
        id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["ListDatasetVersionsResponseBody"];
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Unprocessable Entity */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
    };
  };
  uploadDataset: {
    parameters: {
      query?: {
        /** @description If true, fulfill request synchronously and return JSON containing dataset_id. */
        sync?: boolean;
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: {
      content: {
        "application/json": {
          /** @enum {string} */
          action?: "create" | "append";
          name: string;
          description?: string;
          inputs: Record<string, never>[];
          outputs?: Record<string, never>[];
          metadata?: Record<string, never>[];
        };
        "multipart/form-data": {
          /** @enum {string} */
          action?: "create" | "append";
          name: string;
          description?: string;
          "input_keys[]": string[];
          "output_keys[]": string[];
          "metadata_keys[]"?: string[];
          /** Format: binary */
          file: string;
        };
      };
    };
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json":
            | components["schemas"]["UploadDatasetResponseBody"]
            | null;
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Dataset of the same name already exists */
      409: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Invalid request body */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
    };
  };
  getDatasetExamples: {
    parameters: {
      query?: {
        /** @description The ID of the dataset version (if omitted, returns data from the latest version) */
        version_id?: string | null;
      };
      header?: never;
      path: {
        /** @description The ID of the dataset */
        id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["ListDatasetExamplesResponseBody"];
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Not Found */
      404: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Validation Error */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["HTTPValidationError"];
        };
      };
    };
  };
  getDatasetCsv: {
    parameters: {
      query?: {
        /** @description The ID of the dataset version (if omitted, returns data from the latest version) */
        version_id?: string | null;
      };
      header?: never;
      path: {
        /** @description The ID of the dataset */
        id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/csv": string;
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Unprocessable Entity */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
    };
  };
  getDatasetJSONLOpenAIFineTuning: {
    parameters: {
      query?: {
        /** @description The ID of the dataset version (if omitted, returns data from the latest version) */
        version_id?: string | null;
      };
      header?: never;
      path: {
        /** @description The ID of the dataset */
        id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Invalid dataset or version ID */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
    };
  };
  getDatasetJSONLOpenAIEvals: {
    parameters: {
      query?: {
        /** @description The ID of the dataset version (if omitted, returns data from the latest version) */
        version_id?: string | null;
      };
      header?: never;
      path: {
        /** @description The ID of the dataset */
        id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Invalid dataset or version ID */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
    };
  };
  listExperiments: {
    parameters: {
      query?: never;
      header?: never;
      path: {
        dataset_id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Experiments retrieved successfully */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["ListExperimentsResponseBody"];
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Validation Error */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["HTTPValidationError"];
        };
      };
    };
  };
  createExperiment: {
    parameters: {
      query?: never;
      header?: never;
      path: {
        dataset_id: string;
      };
      cookie?: never;
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["CreateExperimentRequestBody"];
      };
    };
    responses: {
      /** @description Experiment retrieved successfully */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["CreateExperimentResponseBody"];
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Dataset or DatasetVersion not found */
      404: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Validation Error */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["HTTPValidationError"];
        };
      };
    };
  };
  getExperiment: {
    parameters: {
      query?: never;
      header?: never;
      path: {
        experiment_id: string;
      };
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Experiment retrieved successfully */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["GetExperimentResponseBody"];
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Experiment not found */
      404: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Validation Error */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["HTTPValidationError"];
        };
      };
    };
  };
  annotateSpans: {
    parameters: {
      query?: {
        /** @description If true, fulfill request synchronously. */
        sync?: boolean;
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody: {
      content: {
        "application/json": components["schemas"]["AnnotateSpansRequestBody"];
      };
    };
    responses: {
      /** @description Span annotations inserted successfully */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["AnnotateSpansResponseBody"];
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Span not found */
      404: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Validation Error */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["HTTPValidationError"];
        };
      };
    };
  };
  getEvaluations: {
    parameters: {
      query?: {
        /** @description The name of the project to get evaluations from (if omitted, evaluations will be drawn from the `default` project) */
        project_name?: string | null;
      };
      header?: never;
      path?: never;
      cookie?: never;
    };
    requestBody?: never;
    responses: {
      /** @description Successful Response */
      200: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": unknown;
        };
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Not Found */
      404: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Validation Error */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "application/json": components["schemas"]["HTTPValidationError"];
        };
      };
    };
  };
  addEvaluations: {
    parameters: {
      query?: never;
      header?: {
        "content-type"?: string | null;
        "content-encoding"?: string | null;
      };
      path?: never;
      cookie?: never;
    };
    requestBody: {
      content: {
        "application/x-protobuf": string;
        "application/x-pandas-arrow": string;
      };
    };
    responses: {
      /** @description Successful Response */
      204: {
        headers: {
          [name: string]: unknown;
        };
        content?: never;
      };
      /** @description Forbidden */
      403: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Unsupported content type, only gzipped protobuf and pandas-arrow are supported */
      415: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
      /** @description Unprocessable Entity */
      422: {
        headers: {
          [name: string]: unknown;
        };
        content: {
          "text/plain": string;
        };
      };
    };
  };
}