/*
 * 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 { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";

export type ConnectionMetadata =
  | string
  | number
  | number
  | boolean
  | Array<string>;

export type Source = string | Array<string> | { [k: string]: any };

export const DisabledBySystemReason = {
  ConnectionOverTotalPageLimit: "connection_over_total_page_limit",
  AuthenticationFailed: "authentication_failed",
} as const;
export type DisabledBySystemReason = ClosedEnum<typeof DisabledBySystemReason>;

export type Connection = {
  id: string;
  createdAt: Date;
  updatedAt: Date;
  metadata: { [k: string]: string | number | number | boolean | Array<string> };
  type: string;
  name: string;
  source: string | Array<string> | { [k: string]: any } | null;
  enabled: boolean;
  disabledBySystemReason: DisabledBySystemReason | null;
  lastSyncedAt?: Date | null | undefined;
  syncing?: boolean | null | undefined;
  partition?: string | null | undefined;
  pageLimit: number | null;
  disabledBySystem: boolean;
};

/** @internal */
export const ConnectionMetadata$inboundSchema: z.ZodType<
  ConnectionMetadata,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.string(),
  z.number().int(),
  z.number(),
  z.boolean(),
  z.array(z.string()),
]);
/** @internal */
export type ConnectionMetadata$Outbound =
  | string
  | number
  | number
  | boolean
  | Array<string>;

/** @internal */
export const ConnectionMetadata$outboundSchema: z.ZodType<
  ConnectionMetadata$Outbound,
  z.ZodTypeDef,
  ConnectionMetadata
> = z.union([
  z.string(),
  z.number().int(),
  z.number(),
  z.boolean(),
  z.array(z.string()),
]);

export function connectionMetadataToJSON(
  connectionMetadata: ConnectionMetadata,
): string {
  return JSON.stringify(
    ConnectionMetadata$outboundSchema.parse(connectionMetadata),
  );
}
export function connectionMetadataFromJSON(
  jsonString: string,
): SafeParseResult<ConnectionMetadata, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ConnectionMetadata$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ConnectionMetadata' from JSON`,
  );
}

/** @internal */
export const Source$inboundSchema: z.ZodType<Source, z.ZodTypeDef, unknown> = z
  .union([z.string(), z.array(z.string()), z.record(z.any())]);
/** @internal */
export type Source$Outbound = string | Array<string> | { [k: string]: any };

/** @internal */
export const Source$outboundSchema: z.ZodType<
  Source$Outbound,
  z.ZodTypeDef,
  Source
> = z.union([z.string(), z.array(z.string()), z.record(z.any())]);

export function sourceToJSON(source: Source): string {
  return JSON.stringify(Source$outboundSchema.parse(source));
}
export function sourceFromJSON(
  jsonString: string,
): SafeParseResult<Source, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Source$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Source' from JSON`,
  );
}

/** @internal */
export const DisabledBySystemReason$inboundSchema: z.ZodNativeEnum<
  typeof DisabledBySystemReason
> = z.nativeEnum(DisabledBySystemReason);
/** @internal */
export const DisabledBySystemReason$outboundSchema: z.ZodNativeEnum<
  typeof DisabledBySystemReason
> = DisabledBySystemReason$inboundSchema;

/** @internal */
export const Connection$inboundSchema: z.ZodType<
  Connection,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.string(),
  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
  metadata: z.record(
    z.union([
      z.string(),
      z.number().int(),
      z.number(),
      z.boolean(),
      z.array(z.string()),
    ]),
  ),
  type: z.string(),
  name: z.string(),
  source: z.nullable(
    z.union([z.string(), z.array(z.string()), z.record(z.any())]),
  ),
  enabled: z.boolean(),
  disabled_by_system_reason: z.nullable(DisabledBySystemReason$inboundSchema),
  last_synced_at: z.nullable(
    z.string().datetime({ offset: true }).transform(v => new Date(v)),
  ).optional(),
  syncing: z.nullable(z.boolean()).optional(),
  partition: z.nullable(z.string()).optional(),
  page_limit: z.nullable(z.number().int()),
  disabled_by_system: z.boolean(),
}).transform((v) => {
  return remap$(v, {
    "created_at": "createdAt",
    "updated_at": "updatedAt",
    "disabled_by_system_reason": "disabledBySystemReason",
    "last_synced_at": "lastSyncedAt",
    "page_limit": "pageLimit",
    "disabled_by_system": "disabledBySystem",
  });
});
/** @internal */
export type Connection$Outbound = {
  id: string;
  created_at: string;
  updated_at: string;
  metadata: { [k: string]: string | number | number | boolean | Array<string> };
  type: string;
  name: string;
  source: string | Array<string> | { [k: string]: any } | null;
  enabled: boolean;
  disabled_by_system_reason: string | null;
  last_synced_at?: string | null | undefined;
  syncing?: boolean | null | undefined;
  partition?: string | null | undefined;
  page_limit: number | null;
  disabled_by_system: boolean;
};

/** @internal */
export const Connection$outboundSchema: z.ZodType<
  Connection$Outbound,
  z.ZodTypeDef,
  Connection
> = z.object({
  id: z.string(),
  createdAt: z.date().transform(v => v.toISOString()),
  updatedAt: z.date().transform(v => v.toISOString()),
  metadata: z.record(
    z.union([
      z.string(),
      z.number().int(),
      z.number(),
      z.boolean(),
      z.array(z.string()),
    ]),
  ),
  type: z.string(),
  name: z.string(),
  source: z.nullable(
    z.union([z.string(), z.array(z.string()), z.record(z.any())]),
  ),
  enabled: z.boolean(),
  disabledBySystemReason: z.nullable(DisabledBySystemReason$outboundSchema),
  lastSyncedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  syncing: z.nullable(z.boolean()).optional(),
  partition: z.nullable(z.string()).optional(),
  pageLimit: z.nullable(z.number().int()),
  disabledBySystem: z.boolean(),
}).transform((v) => {
  return remap$(v, {
    createdAt: "created_at",
    updatedAt: "updated_at",
    disabledBySystemReason: "disabled_by_system_reason",
    lastSyncedAt: "last_synced_at",
    pageLimit: "page_limit",
    disabledBySystem: "disabled_by_system",
  });
});

export function connectionToJSON(connection: Connection): string {
  return JSON.stringify(Connection$outboundSchema.parse(connection));
}
export function connectionFromJSON(
  jsonString: string,
): SafeParseResult<Connection, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Connection$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Connection' from JSON`,
  );
}