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

import * as z from "zod/v3";
import { remap as remap$ } from "../../lib/primitives.js";
import { safeParse } from "../../lib/schemas.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";

/**
 * The initial version created with this prompt
 */
export type Version = {
  /**
   * Unique version identifier
   */
  id: string;
  /**
   * Parent prompt identifier
   */
  promptId: string;
  /**
   * Version number
   */
  version: number;
  /**
   * Object type
   */
  object: "prompt.version";
  /**
   * The prompt template text with {{variable}} placeholders
   */
  template: string;
  /**
   * Timestamp when this version was created
   */
  createdAt: Date;
};

export type CreatePromptResponse = {
  /**
   * Unique prompt identifier
   */
  id: string;
  /**
   * Object type
   */
  object: "prompt";
  /**
   * Human-readable prompt name
   */
  name: string;
  /**
   * Detailed description of the prompt
   */
  description?: string | undefined;
  /**
   * Currently active version number
   */
  activeVersion: number;
  /**
   * Most recent version number
   */
  latestVersion: number;
  /**
   * Custom metadata key-value pairs
   */
  metadata: { [k: string]: any };
  /**
   * Timestamp when the prompt was created
   */
  createdAt: Date;
  /**
   * Timestamp when the prompt was last updated
   */
  updatedAt: Date;
  /**
   * The initial version created with this prompt
   */
  version: Version;
};

/** @internal */
export const Version$inboundSchema: z.ZodType<Version, z.ZodTypeDef, unknown> =
  z.object({
    id: z.string(),
    prompt_id: z.string(),
    version: z.number().int(),
    object: z.literal("prompt.version"),
    template: z.string(),
    created_at: z.string().datetime({ offset: true }).transform(v =>
      new Date(v)
    ),
  }).transform((v) => {
    return remap$(v, {
      "prompt_id": "promptId",
      "created_at": "createdAt",
    });
  });
/** @internal */
export type Version$Outbound = {
  id: string;
  prompt_id: string;
  version: number;
  object: "prompt.version";
  template: string;
  created_at: string;
};

/** @internal */
export const Version$outboundSchema: z.ZodType<
  Version$Outbound,
  z.ZodTypeDef,
  Version
> = z.object({
  id: z.string(),
  promptId: z.string(),
  version: z.number().int(),
  object: z.literal("prompt.version"),
  template: z.string(),
  createdAt: z.date().transform(v => v.toISOString()),
}).transform((v) => {
  return remap$(v, {
    promptId: "prompt_id",
    createdAt: "created_at",
  });
});

export function versionToJSON(version: Version): string {
  return JSON.stringify(Version$outboundSchema.parse(version));
}
export function versionFromJSON(
  jsonString: string,
): SafeParseResult<Version, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Version$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Version' from JSON`,
  );
}

/** @internal */
export const CreatePromptResponse$inboundSchema: z.ZodType<
  CreatePromptResponse,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.string(),
  object: z.literal("prompt"),
  name: z.string(),
  description: z.string().optional(),
  active_version: z.number().int(),
  latest_version: z.number().int(),
  metadata: z.record(z.any()),
  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
  version: z.lazy(() => Version$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "active_version": "activeVersion",
    "latest_version": "latestVersion",
    "created_at": "createdAt",
    "updated_at": "updatedAt",
  });
});
/** @internal */
export type CreatePromptResponse$Outbound = {
  id: string;
  object: "prompt";
  name: string;
  description?: string | undefined;
  active_version: number;
  latest_version: number;
  metadata: { [k: string]: any };
  created_at: string;
  updated_at: string;
  version: Version$Outbound;
};

/** @internal */
export const CreatePromptResponse$outboundSchema: z.ZodType<
  CreatePromptResponse$Outbound,
  z.ZodTypeDef,
  CreatePromptResponse
> = z.object({
  id: z.string(),
  object: z.literal("prompt"),
  name: z.string(),
  description: z.string().optional(),
  activeVersion: z.number().int(),
  latestVersion: z.number().int(),
  metadata: z.record(z.any()),
  createdAt: z.date().transform(v => v.toISOString()),
  updatedAt: z.date().transform(v => v.toISOString()),
  version: z.lazy(() => Version$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    activeVersion: "active_version",
    latestVersion: "latest_version",
    createdAt: "created_at",
    updatedAt: "updated_at",
  });
});

export function createPromptResponseToJSON(
  createPromptResponse: CreatePromptResponse,
): string {
  return JSON.stringify(
    CreatePromptResponse$outboundSchema.parse(createPromptResponse),
  );
}
export function createPromptResponseFromJSON(
  jsonString: string,
): SafeParseResult<CreatePromptResponse, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreatePromptResponse$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreatePromptResponse' from JSON`,
  );
}