Request and Response Management

/**
 * Check if operation has a request body
 * @returns True if operation defines a request body
 */
hasRequestBody(): boolean;

/**
 * Check if request body is required
 * @returns True if request body is marked as required or has required properties
 */
hasRequiredRequestBody(): boolean;

const operation = oas.operation("/users", "post");

if (operation.hasRequestBody()) {
  console.log("Operation accepts request body");
  
  if (operation.hasRequiredRequestBody()) {
    console.log("Request body is required");
  }
}

/**
 * Get all available media types for the request body
 * @returns Array of media type strings (e.g., ["application/json", "multipart/form-data"])
 */
getRequestBodyMediaTypes(): string[];

const mediaTypes = operation.getRequestBodyMediaTypes();
console.log("Supported media types:", mediaTypes);

// Check for specific formats
const supportsJson = mediaTypes.some(type => type.includes("json"));
const supportsFormData = mediaTypes.some(type => type.includes("form-data"));
const supportsXml = mediaTypes.some(type => type.includes("xml"));

/**
 * Get request body content for a specific media type
 * @param mediaType - Specific media type to retrieve (optional)
 * @returns Media type object, or array with selected type and description, or false if not found
 */
getRequestBody(mediaType?: string): MediaTypeObject | false | [string, MediaTypeObject, ...string[]];

// Get specific media type
const jsonBody = operation.getRequestBody("application/json");
if (jsonBody && typeof jsonBody === 'object' && 'schema' in jsonBody) {
  console.log("JSON schema:", jsonBody.schema);
}

// Auto-select best media type (prefers JSON)
const autoBody = operation.getRequestBody();
if (Array.isArray(autoBody)) {
  const [selectedType, mediaTypeObj, description] = autoBody;
  console.log(`Selected: ${selectedType}`);
  console.log(`Schema:`, mediaTypeObj.schema);
  if (description) console.log(`Description: ${description}`);
}

// Handle missing request body
const noBody = operation.getRequestBody("text/plain");
if (noBody === false) {
  console.log("Media type not supported");
}

/**
 * Get request body examples for this operation
 * @returns Array of request body examples with metadata
 */
getRequestBodyExamples(): RequestBodyExamples;

const examples = operation.getRequestBodyExamples();

examples.forEach(example => {
  console.log(`Media type: ${example.mediaType}`);
  
  example.examples.forEach(ex => {
    console.log(`Example: ${ex.key || 'default'}`);
    console.log(`Value:`, JSON.stringify(ex.value, null, 2));
    if (ex.summary) console.log(`Summary: ${ex.summary}`);
  });
});

/**
 * Get all defined response status codes for this operation
 * @returns Array of status code strings (e.g., ["200", "400", "404", "default"])
 */
getResponseStatusCodes(): string[];

const statusCodes = operation.getResponseStatusCodes();
console.log("Defined responses:", statusCodes);

// Categorize responses
const successCodes = statusCodes.filter(code => code.startsWith('2'));
const errorCodes = statusCodes.filter(code => code.startsWith('4') || code.startsWith('5'));
const hasDefault = statusCodes.includes('default');

/**
 * Get response object for a specific status code
 * @param statusCode - Status code to retrieve (number or string)
 * @returns Response object or false if not found
 */
getResponseByStatusCode(statusCode: number | string): ResponseObject | boolean;

// Get success response
const successResponse = operation.getResponseByStatusCode(200);
if (successResponse && typeof successResponse === 'object') {
  console.log("Success description:", successResponse.description);
  
  if (successResponse.content) {
    console.log("Response content types:", Object.keys(successResponse.content));
  }
  
  if (successResponse.headers) {
    console.log("Response headers:", Object.keys(successResponse.headers));
  }
}

// Get error response
const errorResponse = operation.getResponseByStatusCode("400");
if (errorResponse) {
  console.log("Error response defined");
}

// Handle missing response
const missing = operation.getResponseByStatusCode(418);
if (missing === false) {
  console.log("Status code not defined");
}

/**
 * Convert response to JSON Schema format
 * @param statusCode - Status code to convert
 * @param opts - Conversion options
 * @returns JSON Schema representation of the response
 */
getResponseAsJSONSchema(
  statusCode: number | string,
  opts?: {
    includeDiscriminatorMappingRefs?: boolean;
    transformer?: (schema: SchemaObject) => SchemaObject;
  }
): SchemaObject;

// Get response schema
const responseSchema = operation.getResponseAsJSONSchema(200);
console.log("Response schema:", responseSchema);

// With transformation
const transformedSchema = operation.getResponseAsJSONSchema(200, {
  transformer: (schema) => {
    // Add validation metadata
    schema.additionalProperties = false;
    return schema;
  }
});

// For multiple content types, schema represents the first JSON-like type
const schema = operation.getResponseAsJSONSchema("200");
if (schema.type === 'object') {
  console.log("Response properties:", Object.keys(schema.properties || {}));
}

/**
 * Get response examples for this operation
 * @returns Array of response examples organized by status code and media type
 */
getResponseExamples(): ResponseExamples;

const responseExamples = operation.getResponseExamples();

responseExamples.forEach(example => {
  console.log(`Status: ${example.status}`);
  console.log(`Media type: ${example.mediaType}`);
  
  example.examples.forEach(ex => {
    console.log(`Example: ${ex.key || 'default'}`);
    console.log(`Value:`, JSON.stringify(ex.value, null, 2));
    if (ex.summary) console.log(`Summary: ${ex.summary}`);
  });
});

/**
 * Get all request and response headers for this operation
 * @returns Object with request and response header arrays
 */
getHeaders(): {
  request: string[];
  response: string[];
};

const headers = operation.getHeaders();

console.log("Request headers:");
headers.request.forEach(header => {
  console.log(`  ${header}`);
});

console.log("Response headers:");  
headers.response.forEach(header => {
  console.log(`  ${header}`);
});

// Check for specific headers
const hasAuth = headers.request.includes('Authorization');
const hasContentType = headers.request.includes('Content-Type');
const hasAccept = headers.request.includes('Accept');

// Handle operations with multiple response content types
const response = operation.getResponseByStatusCode(200);
if (response && typeof response === 'object' && response.content) {
  const contentTypes = Object.keys(response.content);
  
  contentTypes.forEach(contentType => {
    const mediaTypeObj = response.content[contentType];
    console.log(`${contentType}:`, mediaTypeObj.schema);
    
    // Get examples for this content type
    if (mediaTypeObj.examples) {
      Object.entries(mediaTypeObj.examples).forEach(([key, example]) => {
        console.log(`  Example ${key}:`, example.value);
      });
    }
  });
}

// Analyze error response patterns
const errorCodes = operation.getResponseStatusCodes()
  .filter(code => code.startsWith('4') || code.startsWith('5'));

errorCodes.forEach(code => {
  const errorResponse = operation.getResponseByStatusCode(code);
  if (errorResponse && typeof errorResponse === 'object') {
    console.log(`Error ${code}: ${errorResponse.description}`);
    
    // Get error schema
    const errorSchema = operation.getResponseAsJSONSchema(code);
    if (errorSchema.properties) {
      console.log("Error fields:", Object.keys(errorSchema.properties));
    }
  }
});

// Handle content negotiation
const requestTypes = operation.getRequestBodyMediaTypes();
const responseTypes = operation.getResponseStatusCodes()
  .map(code => {
    const response = operation.getResponseByStatusCode(code);
    if (response && typeof response === 'object' && response.content) {
      return Object.keys(response.content);
    }
    return [];
  })
  .flat();

console.log("Accepts:", requestTypes);
console.log("Produces:", [...new Set(responseTypes)]);

interface RequestBodyExamples {
  mediaType: string;
  examples: Array<{
    key?: string;
    value: any;
    summary?: string;
    description?: string;
  }>;
}

interface ResponseExamples {
  status: string;
  mediaType: string;
  examples: Array<{
    key?: string;
    value: any;
    summary?: string;
    description?: string;
  }>;
}

interface MediaTypeObject {
  schema?: SchemaObject;
  example?: any;
  examples?: Record<string, ExampleObject>;
  encoding?: Record<string, EncodingObject>;
}

interface ResponseObject {
  description: string;
  headers?: Record<string, HeaderObject>;
  content?: Record<string, MediaTypeObject>;
  links?: Record<string, LinkObject>;
}

// Safe handling of missing data
const operation = oas.operation("/nonexistent", "get");

const hasBody = operation.hasRequestBody(); // false
const mediaTypes = operation.getRequestBodyMediaTypes(); // []
const examples = operation.getRequestBodyExamples(); // []
const statusCodes = operation.getResponseStatusCodes(); // []