/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import * as z from "zod/v3";
import { safeParse } from "../../lib/schemas.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKError } from "./sdkerror.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

export type GetFileContentLlmFilesResponseError = {
  message?: string | undefined;
  type?: string | undefined;
  code?: number | undefined;
};

/**
 * Internal server error
 */
export type GetFileContentLlmFilesResponse500ResponseBodyData = {
  error?: GetFileContentLlmFilesResponseError | undefined;
};

/**
 * Internal server error
 */
export class GetFileContentLlmFilesResponse500ResponseBody extends SDKError {
  error?: GetFileContentLlmFilesResponseError | undefined;

  /** The original data that was passed to this error instance. */
  data$: GetFileContentLlmFilesResponse500ResponseBodyData;

  constructor(
    err: GetFileContentLlmFilesResponse500ResponseBodyData,
    httpMeta: { response: Response; request: Request; body: string },
  ) {
    const message = err.error?.message
      || `API error occurred: ${JSON.stringify(err)}`;
    super(message, httpMeta);
    this.data$ = err;
    if (err.error != null) this.error = err.error;

    this.name = "GetFileContentLlmFilesResponse500ResponseBody";
  }
}

export type GetFileContentLlmFilesError = {
  message?: string | undefined;
  type?: string | undefined;
  code?: number | undefined;
};

/**
 * File not found
 */
export type GetFileContentLlmFilesResponseResponseBodyData = {
  error?: GetFileContentLlmFilesError | undefined;
};

/**
 * File not found
 */
export class GetFileContentLlmFilesResponseResponseBody extends SDKError {
  error?: GetFileContentLlmFilesError | undefined;

  /** The original data that was passed to this error instance. */
  data$: GetFileContentLlmFilesResponseResponseBodyData;

  constructor(
    err: GetFileContentLlmFilesResponseResponseBodyData,
    httpMeta: { response: Response; request: Request; body: string },
  ) {
    const message = err.error?.message
      || `API error occurred: ${JSON.stringify(err)}`;
    super(message, httpMeta);
    this.data$ = err;
    if (err.error != null) this.error = err.error;

    this.name = "GetFileContentLlmFilesResponseResponseBody";
  }
}

export type GetFileContentError = {
  message?: string | undefined;
  type?: string | undefined;
  code?: number | undefined;
};

/**
 * Unauthorized - Invalid or missing authentication
 */
export type GetFileContentLlmFilesResponseBodyData = {
  error?: GetFileContentError | undefined;
};

/**
 * Unauthorized - Invalid or missing authentication
 */
export class GetFileContentLlmFilesResponseBody extends SDKError {
  error?: GetFileContentError | undefined;

  /** The original data that was passed to this error instance. */
  data$: GetFileContentLlmFilesResponseBodyData;

  constructor(
    err: GetFileContentLlmFilesResponseBodyData,
    httpMeta: { response: Response; request: Request; body: string },
  ) {
    const message = err.error?.message
      || `API error occurred: ${JSON.stringify(err)}`;
    super(message, httpMeta);
    this.data$ = err;
    if (err.error != null) this.error = err.error;

    this.name = "GetFileContentLlmFilesResponseBody";
  }
}

export type GetFileContentLlmFilesResponse400Error = {
  message?: string | undefined;
  type?: string | undefined;
  code?: number | undefined;
};

/**
 * Invalid request - File ID is required
 */
export type GetFileContentResponseBodyData = {
  error?: GetFileContentLlmFilesResponse400Error | undefined;
};

/**
 * Invalid request - File ID is required
 */
export class GetFileContentResponseBody extends SDKError {
  error?: GetFileContentLlmFilesResponse400Error | undefined;

  /** The original data that was passed to this error instance. */
  data$: GetFileContentResponseBodyData;

  constructor(
    err: GetFileContentResponseBodyData,
    httpMeta: { response: Response; request: Request; body: string },
  ) {
    const message = err.error?.message
      || `API error occurred: ${JSON.stringify(err)}`;
    super(message, httpMeta);
    this.data$ = err;
    if (err.error != null) this.error = err.error;

    this.name = "GetFileContentResponseBody";
  }
}

/** @internal */
export const GetFileContentLlmFilesResponseError$inboundSchema: z.ZodType<
  GetFileContentLlmFilesResponseError,
  z.ZodTypeDef,
  unknown
> = z.object({
  message: z.string().optional(),
  type: z.string().optional(),
  code: z.number().int().optional(),
});
/** @internal */
export type GetFileContentLlmFilesResponseError$Outbound = {
  message?: string | undefined;
  type?: string | undefined;
  code?: number | undefined;
};

/** @internal */
export const GetFileContentLlmFilesResponseError$outboundSchema: z.ZodType<
  GetFileContentLlmFilesResponseError$Outbound,
  z.ZodTypeDef,
  GetFileContentLlmFilesResponseError
> = z.object({
  message: z.string().optional(),
  type: z.string().optional(),
  code: z.number().int().optional(),
});

export function getFileContentLlmFilesResponseErrorToJSON(
  getFileContentLlmFilesResponseError: GetFileContentLlmFilesResponseError,
): string {
  return JSON.stringify(
    GetFileContentLlmFilesResponseError$outboundSchema.parse(
      getFileContentLlmFilesResponseError,
    ),
  );
}
export function getFileContentLlmFilesResponseErrorFromJSON(
  jsonString: string,
): SafeParseResult<GetFileContentLlmFilesResponseError, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      GetFileContentLlmFilesResponseError$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'GetFileContentLlmFilesResponseError' from JSON`,
  );
}

/** @internal */
export const GetFileContentLlmFilesResponse500ResponseBody$inboundSchema:
  z.ZodType<
    GetFileContentLlmFilesResponse500ResponseBody,
    z.ZodTypeDef,
    unknown
  > = z.object({
    error: z.lazy(() => GetFileContentLlmFilesResponseError$inboundSchema)
      .optional(),
    request$: z.instanceof(Request),
    response$: z.instanceof(Response),
    body$: z.string(),
  })
    .transform((v) => {
      return new GetFileContentLlmFilesResponse500ResponseBody(v, {
        request: v.request$,
        response: v.response$,
        body: v.body$,
      });
    });

/** @internal */
export type GetFileContentLlmFilesResponse500ResponseBody$Outbound = {
  error?: GetFileContentLlmFilesResponseError$Outbound | undefined;
};

/** @internal */
export const GetFileContentLlmFilesResponse500ResponseBody$outboundSchema:
  z.ZodType<
    GetFileContentLlmFilesResponse500ResponseBody$Outbound,
    z.ZodTypeDef,
    GetFileContentLlmFilesResponse500ResponseBody
  > = z.instanceof(GetFileContentLlmFilesResponse500ResponseBody)
    .transform(v => v.data$)
    .pipe(z.object({
      error: z.lazy(() => GetFileContentLlmFilesResponseError$outboundSchema)
        .optional(),
    }));

/** @internal */
export const GetFileContentLlmFilesError$inboundSchema: z.ZodType<
  GetFileContentLlmFilesError,
  z.ZodTypeDef,
  unknown
> = z.object({
  message: z.string().optional(),
  type: z.string().optional(),
  code: z.number().int().optional(),
});
/** @internal */
export type GetFileContentLlmFilesError$Outbound = {
  message?: string | undefined;
  type?: string | undefined;
  code?: number | undefined;
};

/** @internal */
export const GetFileContentLlmFilesError$outboundSchema: z.ZodType<
  GetFileContentLlmFilesError$Outbound,
  z.ZodTypeDef,
  GetFileContentLlmFilesError
> = z.object({
  message: z.string().optional(),
  type: z.string().optional(),
  code: z.number().int().optional(),
});

export function getFileContentLlmFilesErrorToJSON(
  getFileContentLlmFilesError: GetFileContentLlmFilesError,
): string {
  return JSON.stringify(
    GetFileContentLlmFilesError$outboundSchema.parse(
      getFileContentLlmFilesError,
    ),
  );
}
export function getFileContentLlmFilesErrorFromJSON(
  jsonString: string,
): SafeParseResult<GetFileContentLlmFilesError, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => GetFileContentLlmFilesError$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'GetFileContentLlmFilesError' from JSON`,
  );
}

/** @internal */
export const GetFileContentLlmFilesResponseResponseBody$inboundSchema:
  z.ZodType<GetFileContentLlmFilesResponseResponseBody, z.ZodTypeDef, unknown> =
    z.object({
      error: z.lazy(() => GetFileContentLlmFilesError$inboundSchema).optional(),
      request$: z.instanceof(Request),
      response$: z.instanceof(Response),
      body$: z.string(),
    })
      .transform((v) => {
        return new GetFileContentLlmFilesResponseResponseBody(v, {
          request: v.request$,
          response: v.response$,
          body: v.body$,
        });
      });

/** @internal */
export type GetFileContentLlmFilesResponseResponseBody$Outbound = {
  error?: GetFileContentLlmFilesError$Outbound | undefined;
};

/** @internal */
export const GetFileContentLlmFilesResponseResponseBody$outboundSchema:
  z.ZodType<
    GetFileContentLlmFilesResponseResponseBody$Outbound,
    z.ZodTypeDef,
    GetFileContentLlmFilesResponseResponseBody
  > = z.instanceof(GetFileContentLlmFilesResponseResponseBody)
    .transform(v => v.data$)
    .pipe(z.object({
      error: z.lazy(() => GetFileContentLlmFilesError$outboundSchema)
        .optional(),
    }));

/** @internal */
export const GetFileContentError$inboundSchema: z.ZodType<
  GetFileContentError,
  z.ZodTypeDef,
  unknown
> = z.object({
  message: z.string().optional(),
  type: z.string().optional(),
  code: z.number().int().optional(),
});
/** @internal */
export type GetFileContentError$Outbound = {
  message?: string | undefined;
  type?: string | undefined;
  code?: number | undefined;
};

/** @internal */
export const GetFileContentError$outboundSchema: z.ZodType<
  GetFileContentError$Outbound,
  z.ZodTypeDef,
  GetFileContentError
> = z.object({
  message: z.string().optional(),
  type: z.string().optional(),
  code: z.number().int().optional(),
});

export function getFileContentErrorToJSON(
  getFileContentError: GetFileContentError,
): string {
  return JSON.stringify(
    GetFileContentError$outboundSchema.parse(getFileContentError),
  );
}
export function getFileContentErrorFromJSON(
  jsonString: string,
): SafeParseResult<GetFileContentError, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => GetFileContentError$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'GetFileContentError' from JSON`,
  );
}

/** @internal */
export const GetFileContentLlmFilesResponseBody$inboundSchema: z.ZodType<
  GetFileContentLlmFilesResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  error: z.lazy(() => GetFileContentError$inboundSchema).optional(),
  request$: z.instanceof(Request),
  response$: z.instanceof(Response),
  body$: z.string(),
})
  .transform((v) => {
    return new GetFileContentLlmFilesResponseBody(v, {
      request: v.request$,
      response: v.response$,
      body: v.body$,
    });
  });

/** @internal */
export type GetFileContentLlmFilesResponseBody$Outbound = {
  error?: GetFileContentError$Outbound | undefined;
};

/** @internal */
export const GetFileContentLlmFilesResponseBody$outboundSchema: z.ZodType<
  GetFileContentLlmFilesResponseBody$Outbound,
  z.ZodTypeDef,
  GetFileContentLlmFilesResponseBody
> = z.instanceof(GetFileContentLlmFilesResponseBody)
  .transform(v => v.data$)
  .pipe(z.object({
    error: z.lazy(() => GetFileContentError$outboundSchema).optional(),
  }));

/** @internal */
export const GetFileContentLlmFilesResponse400Error$inboundSchema: z.ZodType<
  GetFileContentLlmFilesResponse400Error,
  z.ZodTypeDef,
  unknown
> = z.object({
  message: z.string().optional(),
  type: z.string().optional(),
  code: z.number().int().optional(),
});
/** @internal */
export type GetFileContentLlmFilesResponse400Error$Outbound = {
  message?: string | undefined;
  type?: string | undefined;
  code?: number | undefined;
};

/** @internal */
export const GetFileContentLlmFilesResponse400Error$outboundSchema: z.ZodType<
  GetFileContentLlmFilesResponse400Error$Outbound,
  z.ZodTypeDef,
  GetFileContentLlmFilesResponse400Error
> = z.object({
  message: z.string().optional(),
  type: z.string().optional(),
  code: z.number().int().optional(),
});

export function getFileContentLlmFilesResponse400ErrorToJSON(
  getFileContentLlmFilesResponse400Error:
    GetFileContentLlmFilesResponse400Error,
): string {
  return JSON.stringify(
    GetFileContentLlmFilesResponse400Error$outboundSchema.parse(
      getFileContentLlmFilesResponse400Error,
    ),
  );
}
export function getFileContentLlmFilesResponse400ErrorFromJSON(
  jsonString: string,
): SafeParseResult<GetFileContentLlmFilesResponse400Error, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      GetFileContentLlmFilesResponse400Error$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'GetFileContentLlmFilesResponse400Error' from JSON`,
  );
}

/** @internal */
export const GetFileContentResponseBody$inboundSchema: z.ZodType<
  GetFileContentResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  error: z.lazy(() => GetFileContentLlmFilesResponse400Error$inboundSchema)
    .optional(),
  request$: z.instanceof(Request),
  response$: z.instanceof(Response),
  body$: z.string(),
})
  .transform((v) => {
    return new GetFileContentResponseBody(v, {
      request: v.request$,
      response: v.response$,
      body: v.body$,
    });
  });

/** @internal */
export type GetFileContentResponseBody$Outbound = {
  error?: GetFileContentLlmFilesResponse400Error$Outbound | undefined;
};

/** @internal */
export const GetFileContentResponseBody$outboundSchema: z.ZodType<
  GetFileContentResponseBody$Outbound,
  z.ZodTypeDef,
  GetFileContentResponseBody
> = z.instanceof(GetFileContentResponseBody)
  .transform(v => v.data$)
  .pipe(z.object({
    error: z.lazy(() => GetFileContentLlmFilesResponse400Error$outboundSchema)
      .optional(),
  }));