/*
 * 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 "./sdkvalidationerror.js";

/**
 * The delivery log format
 */
export const DeliveryFormat = {
  Json: "json",
  Ndjson: "ndjson",
} as const;
/**
 * The delivery log format
 */
export type DeliveryFormat = ClosedEnum<typeof DeliveryFormat>;

export const CreateConfigurableLogDrainSources = {
  Static: "static",
  Lambda: "lambda",
  Build: "build",
  Edge: "edge",
  External: "external",
  Firewall: "firewall",
} as const;
export type CreateConfigurableLogDrainSources = ClosedEnum<
  typeof CreateConfigurableLogDrainSources
>;

export const CreateConfigurableLogDrainEnvironments = {
  Preview: "preview",
  Production: "production",
} as const;
export type CreateConfigurableLogDrainEnvironments = ClosedEnum<
  typeof CreateConfigurableLogDrainEnvironments
>;

export type CreateConfigurableLogDrainRequestBody = {
  /**
   * The delivery log format
   */
  deliveryFormat: DeliveryFormat;
  /**
   * The log drain url
   */
  url: string;
  /**
   * Headers to be sent together with the request
   */
  headers?: { [k: string]: string } | undefined;
  projectIds?: Array<string> | undefined;
  sources: Array<CreateConfigurableLogDrainSources>;
  environments?: Array<CreateConfigurableLogDrainEnvironments> | undefined;
  /**
   * Custom secret of log drain
   */
  secret?: string | undefined;
  /**
   * The sampling rate for this log drain. It should be a percentage rate between 0 and 100. With max 2 decimal points
   */
  samplingRate?: number | undefined;
  /**
   * The custom name of this log drain.
   */
  name?: string | undefined;
};

export type CreateConfigurableLogDrainRequest = {
  /**
   * The Team identifier to perform the request on behalf of.
   */
  teamId?: string | undefined;
  /**
   * The Team slug to perform the request on behalf of.
   */
  slug?: string | undefined;
  requestBody: CreateConfigurableLogDrainRequestBody;
};

export type CreateConfigurableLogDrainResponseBody = {};

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

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

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

/** @internal */
export type CreateConfigurableLogDrainRequestBody$Outbound = {
  deliveryFormat: string;
  url: string;
  headers?: { [k: string]: string } | undefined;
  projectIds?: Array<string> | undefined;
  sources: Array<string>;
  environments?: Array<string> | undefined;
  secret?: string | undefined;
  samplingRate?: number | undefined;
  name?: string | undefined;
};

/** @internal */
export const CreateConfigurableLogDrainRequestBody$outboundSchema: z.ZodType<
  CreateConfigurableLogDrainRequestBody$Outbound,
  z.ZodTypeDef,
  CreateConfigurableLogDrainRequestBody
> = z.object({
  deliveryFormat: DeliveryFormat$outboundSchema,
  url: z.string(),
  headers: z.record(z.string()).optional(),
  projectIds: z.array(z.string()).optional(),
  sources: z.array(CreateConfigurableLogDrainSources$outboundSchema),
  environments: z.array(CreateConfigurableLogDrainEnvironments$outboundSchema)
    .optional(),
  secret: z.string().optional(),
  samplingRate: z.number().optional(),
  name: z.string().optional(),
});

export function createConfigurableLogDrainRequestBodyToJSON(
  createConfigurableLogDrainRequestBody: CreateConfigurableLogDrainRequestBody,
): string {
  return JSON.stringify(
    CreateConfigurableLogDrainRequestBody$outboundSchema.parse(
      createConfigurableLogDrainRequestBody,
    ),
  );
}

/** @internal */
export type CreateConfigurableLogDrainRequest$Outbound = {
  teamId?: string | undefined;
  slug?: string | undefined;
  RequestBody: CreateConfigurableLogDrainRequestBody$Outbound;
};

/** @internal */
export const CreateConfigurableLogDrainRequest$outboundSchema: z.ZodType<
  CreateConfigurableLogDrainRequest$Outbound,
  z.ZodTypeDef,
  CreateConfigurableLogDrainRequest
> = z.object({
  teamId: z.string().optional(),
  slug: z.string().optional(),
  requestBody: z.lazy(() =>
    CreateConfigurableLogDrainRequestBody$outboundSchema
  ),
}).transform((v) => {
  return remap$(v, {
    requestBody: "RequestBody",
  });
});

export function createConfigurableLogDrainRequestToJSON(
  createConfigurableLogDrainRequest: CreateConfigurableLogDrainRequest,
): string {
  return JSON.stringify(
    CreateConfigurableLogDrainRequest$outboundSchema.parse(
      createConfigurableLogDrainRequest,
    ),
  );
}

/** @internal */
export const CreateConfigurableLogDrainResponseBody$inboundSchema: z.ZodType<
  CreateConfigurableLogDrainResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function createConfigurableLogDrainResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<CreateConfigurableLogDrainResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      CreateConfigurableLogDrainResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateConfigurableLogDrainResponseBody' from JSON`,
  );
}