Variable CaddyRouteSchemaConst

CaddyRouteSchema: ZodObject<
    {
        "@id": ZodOptional<ZodString>;
        handle: ZodArray<
            ZodType<
                { handler: string; [key: string]: unknown },
                ZodTypeDef,
                { handler: string; [key: string]: unknown },
            >,
            "many",
        >;
        match: ZodOptional<
            ZodArray<
                ZodObject<
                    {
                        client_ip: ZodOptional<
                            ZodObject<
                                { ranges: ZodOptional<ZodArray<(...), (...)>> },
                                "strip",
                                ZodTypeAny,
                                { ranges?: (...)[] },
                                { ranges?: (...)[] },
                            >,
                        >;
                        expression: ZodOptional<ZodString>;
                        file: ZodOptional<
                            ZodObject<
                                {
                                    fs: ZodOptional<ZodString>;
                                    root: ZodOptional<ZodString>;
                                    split_path: ZodOptional<ZodArray<(...), (...)>>;
                                    try_files: ZodOptional<ZodArray<(...), (...)>>;
                                    try_policy: ZodOptional<ZodString>;
                                },
                                "strip",
                                ZodTypeAny,
                                {
                                    fs?: string;
                                    root?: string;
                                    split_path?: (...)[];
                                    try_files?: (...)[];
                                    try_policy?: string;
                                },
                                {
                                    fs?: string;
                                    root?: string;
                                    split_path?: (...)[];
                                    try_files?: (...)[];
                                    try_policy?: string;
                                },
                            >,
                        >;
                        header: ZodOptional<ZodRecord<ZodString, ZodArray<ZodString, "many">>>;
                        header_regexp: ZodOptional<
                            ZodRecord<
                                ZodString,
                                ZodUnion<
                                    [ZodObject<(...), (...), (...), (...), (...)>, ZodUndefined],
                                >,
                            >,
                        >;
                        host: ZodOptional<ZodArray<ZodString, "many">>;
                        method: ZodOptional<ZodArray<ZodString, "many">>;
                        not: ZodOptional<ZodArray<ZodRecord<ZodString, ZodUnknown>, "many">>;
                        path: ZodOptional<ZodArray<ZodString, "many">>;
                        path_regexp: ZodOptional<
                            ZodObject<
                                { name: ZodOptional<ZodString>; pattern: ZodString },
                                "strip",
                                ZodTypeAny,
                                { name?: string; pattern: string },
                                { name?: string; pattern: string },
                            >,
                        >;
                        protocol: ZodOptional<ZodString>;
                        query: ZodOptional<ZodRecord<ZodString, ZodArray<ZodString, "many">>>;
                        remote_ip: ZodOptional<
                            ZodObject<
                                { ranges: ZodOptional<ZodArray<(...), (...)>> },
                                "strip",
                                ZodTypeAny,
                                { ranges?: (...)[] },
                                { ranges?: (...)[] },
                            >,
                        >;
                        tls: ZodOptional<
                            ZodObject<
                                { handshake_complete: ZodOptional<ZodBoolean> },
                                "strip",
                                ZodTypeAny,
                                { handshake_complete?: boolean },
                                { handshake_complete?: boolean },
                            >,
                        >;
                    },
                    "strip",
                    ZodTypeAny,
                    {
                        client_ip?: { ranges?: string[] };
                        expression?: string;
                        file?: {
                            fs?: string;
                            root?: string;
                            split_path?: string[];
                            try_files?: string[];
                            try_policy?: string;
                        };
                        header?: Record<string, string[]>;
                        header_regexp?: Record<
                            string,
                            { name?: (...) | (...); pattern: string }
                            | undefined,
                        >;
                        host?: string[];
                        method?: string[];
                        not?: Record<string, unknown>[];
                        path?: string[];
                        path_regexp?: { name?: string; pattern: string };
                        protocol?: string;
                        query?: Record<string, string[]>;
                        remote_ip?: { ranges?: string[] };
                        tls?: { handshake_complete?: boolean };
                    },
                    {
                        client_ip?: { ranges?: string[] };
                        expression?: string;
                        file?: {
                            fs?: string;
                            root?: string;
                            split_path?: string[];
                            try_files?: string[];
                            try_policy?: string;
                        };
                        header?: Record<string, string[]>;
                        header_regexp?: Record<
                            string,
                            { name?: (...) | (...); pattern: string }
                            | undefined,
                        >;
                        host?: string[];
                        method?: string[];
                        not?: Record<string, unknown>[];
                        path?: string[];
                        path_regexp?: { name?: string; pattern: string };
                        protocol?: string;
                        query?: Record<string, string[]>;
                        remote_ip?: { ranges?: string[] };
                        tls?: { handshake_complete?: boolean };
                    },
                >,
                "many",
            >,
        >;
        priority: ZodOptional<ZodNumber>;
        terminal: ZodOptional<ZodBoolean>;
    },
    "strip",
    ZodTypeAny,
    {
        "@id"?: string;
        handle: { handler: string; [key: string]: unknown }[];
        match?: {
            client_ip?: { ranges?: string[] };
            expression?: string;
            file?: {
                fs?: string;
                root?: string;
                split_path?: string[];
                try_files?: string[];
                try_policy?: string;
            };
            header?: Record<string, string[]>;
            header_regexp?: Record<
                string,
                { name?: string; pattern: string }
                | undefined,
            >;
            host?: string[];
            method?: string[];
            not?: Record<string, unknown>[];
            path?: string[];
            path_regexp?: { name?: string; pattern: string };
            protocol?: string;
            query?: Record<string, string[]>;
            remote_ip?: { ranges?: string[] };
            tls?: { handshake_complete?: boolean };
        }[];
        priority?: number;
        terminal?: boolean;
    },
    {
        "@id"?: string;
        handle: { handler: string; [key: string]: unknown }[];
        match?: {
            client_ip?: { ranges?: string[] };
            expression?: string;
            file?: {
                fs?: string;
                root?: string;
                split_path?: string[];
                try_files?: string[];
                try_policy?: string;
            };
            header?: Record<string, string[]>;
            header_regexp?: Record<
                string,
                { name?: string; pattern: string }
                | undefined,
            >;
            host?: string[];
            method?: string[];
            not?: Record<string, unknown>[];
            path?: string[];
            path_regexp?: { name?: string; pattern: string };
            protocol?: string;
            query?: Record<string, string[]>;
            remote_ip?: { ranges?: string[] };
            tls?: { handshake_complete?: boolean };
        }[];
        priority?: number;
        terminal?: boolean;
    },
> = ...

import { CaddyRouteSchema } from "@accelerated-software-development/caddy-api-client";

// Validate a route before adding to Caddy
const route = CaddyRouteSchema.parse({
  "@id": "my-api-route",
  match: [{ host: ["api.example.com"] }],
  handle: [{ handler: "reverse_proxy", upstreams: [{ dial: "localhost:3000" }] }],
  terminal: true
});

await client.addRoute("https_server", route);
Copy