convex/dist/cjs-types/cli/lib/deployApi/startPush.d.ts

Client for the Convex Cloud

import { z } from "zod";
export declare const startPushRequest: z.ZodObject<{
    adminKey: z.ZodString;
    dryRun: z.ZodBoolean;
    functions: z.ZodString;
    appDefinition: z.ZodObject<{
        definition: z.ZodNullable<z.ZodObject<{
            path: z.ZodString;
            source: z.ZodString;
            sourceMap: z.ZodOptional<z.ZodString>;
            environment: z.ZodUnion<[z.ZodLiteral<"isolate">, z.ZodLiteral<"node">]>;
        }, "strip", z.ZodTypeAny, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }>>;
        dependencies: z.ZodArray<z.ZodString, "many">;
        schema: z.ZodNullable<z.ZodObject<{
            path: z.ZodString;
            source: z.ZodString;
            sourceMap: z.ZodOptional<z.ZodString>;
            environment: z.ZodUnion<[z.ZodLiteral<"isolate">, z.ZodLiteral<"node">]>;
        }, "strip", z.ZodTypeAny, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }>>;
        functions: z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            source: z.ZodString;
            sourceMap: z.ZodOptional<z.ZodString>;
            environment: z.ZodUnion<[z.ZodLiteral<"isolate">, z.ZodLiteral<"node">]>;
        }, "strip", z.ZodTypeAny, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }>, "many">;
        udfServerVersion: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        definition: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        schema: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        functions: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }[];
        udfServerVersion: string;
        dependencies: string[];
    }, {
        definition: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        schema: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        functions: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }[];
        udfServerVersion: string;
        dependencies: string[];
    }>;
    componentDefinitions: z.ZodArray<z.ZodObject<{
        definitionPath: z.ZodString;
        definition: z.ZodObject<{
            path: z.ZodString;
            source: z.ZodString;
            sourceMap: z.ZodOptional<z.ZodString>;
            environment: z.ZodUnion<[z.ZodLiteral<"isolate">, z.ZodLiteral<"node">]>;
        }, "strip", z.ZodTypeAny, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }>;
        dependencies: z.ZodArray<z.ZodString, "many">;
        schema: z.ZodNullable<z.ZodObject<{
            path: z.ZodString;
            source: z.ZodString;
            sourceMap: z.ZodOptional<z.ZodString>;
            environment: z.ZodUnion<[z.ZodLiteral<"isolate">, z.ZodLiteral<"node">]>;
        }, "strip", z.ZodTypeAny, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }>>;
        functions: z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            source: z.ZodString;
            sourceMap: z.ZodOptional<z.ZodString>;
            environment: z.ZodUnion<[z.ZodLiteral<"isolate">, z.ZodLiteral<"node">]>;
        }, "strip", z.ZodTypeAny, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }, {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }>, "many">;
        udfServerVersion: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        definition: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        };
        schema: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        functions: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }[];
        udfServerVersion: string;
        definitionPath: string;
        dependencies: string[];
    }, {
        definition: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        };
        schema: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        functions: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }[];
        udfServerVersion: string;
        definitionPath: string;
        dependencies: string[];
    }>, "many">;
    nodeDependencies: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        version: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        version: string;
    }, {
        name: string;
        version: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    adminKey: string;
    dryRun: boolean;
    functions: string;
    nodeDependencies: {
        name: string;
        version: string;
    }[];
    appDefinition: {
        definition: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        schema: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        functions: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }[];
        udfServerVersion: string;
        dependencies: string[];
    };
    componentDefinitions: {
        definition: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        };
        schema: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        functions: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }[];
        udfServerVersion: string;
        definitionPath: string;
        dependencies: string[];
    }[];
}, {
    adminKey: string;
    dryRun: boolean;
    functions: string;
    nodeDependencies: {
        name: string;
        version: string;
    }[];
    appDefinition: {
        definition: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        schema: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        functions: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }[];
        udfServerVersion: string;
        dependencies: string[];
    };
    componentDefinitions: {
        definition: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        };
        schema: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        } | null;
        functions: {
            path: string;
            source: string;
            environment: "node" | "isolate";
            sourceMap?: string | undefined;
        }[];
        udfServerVersion: string;
        definitionPath: string;
        dependencies: string[];
    }[];
}>;
export type StartPushRequest = z.infer<typeof startPushRequest>;
export declare const schemaChange: z.ZodObject<{
    allocatedComponentIds: z.ZodAny;
    schemaIds: z.ZodAny;
}, "strip", z.ZodTypeAny, {
    allocatedComponentIds?: any;
    schemaIds?: any;
}, {
    allocatedComponentIds?: any;
    schemaIds?: any;
}>;
export type SchemaChange = z.infer<typeof schemaChange>;
export declare const startPushResponse: z.ZodObject<{
    externalDepsId: z.ZodNullable<z.ZodString>;
    componentDefinitionPackages: z.ZodRecord<z.ZodString, z.ZodAny>;
    appAuth: z.ZodArray<z.ZodObject<{
        applicationID: z.ZodString;
        domain: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        applicationID: string;
        domain: string;
    }, {
        applicationID: string;
        domain: string;
    }>, "many">;
    analysis: z.ZodRecord<z.ZodString, z.ZodObject<{
        definition: z.ZodObject<{
            path: z.ZodString;
            definitionType: z.ZodUnion<[z.ZodObject<{
                type: z.ZodLiteral<"app">;
            }, "strip", z.ZodTypeAny, {
                type: "app";
            }, {
                type: "app";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"childComponent">;
                name: z.ZodString;
                args: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodObject<{
                    type: z.ZodLiteral<"value">;
                    value: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    type: "value";
                    value: string;
                }, {
                    type: "value";
                    value: string;
                }>], null>, "many">;
            }, "strip", z.ZodTypeAny, {
                type: "childComponent";
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][];
            }, {
                type: "childComponent";
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][];
            }>]>;
            childComponents: z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                path: z.ZodString;
                args: z.ZodNullable<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodObject<{
                    type: z.ZodLiteral<"value">;
                    value: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    type: "value";
                    value: string;
                }, {
                    type: "value";
                    value: string;
                }>], null>, "many">>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][] | null;
                path: string;
            }, {
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][] | null;
                path: string;
            }>, "many">;
            httpMounts: z.ZodRecord<z.ZodString, z.ZodString>;
            exports: z.ZodObject<{
                type: z.ZodLiteral<"branch">;
                branch: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodType<import("./componentDefinition.js").ComponentExports, z.ZodTypeDef, import("./componentDefinition.js").ComponentExports>], null>, "many">;
            }, "strip", z.ZodTypeAny, {
                type: "branch";
                branch: [string, import("./componentDefinition.js").ComponentExports][];
            }, {
                type: "branch";
                branch: [string, import("./componentDefinition.js").ComponentExports][];
            }>;
        }, "strip", z.ZodTypeAny, {
            path: string;
            childComponents: {
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][] | null;
                path: string;
            }[];
            exports: {
                type: "branch";
                branch: [string, import("./componentDefinition.js").ComponentExports][];
            };
            definitionType: {
                type: "app";
            } | {
                type: "childComponent";
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][];
            };
            httpMounts: Record<string, string>;
        }, {
            path: string;
            childComponents: {
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][] | null;
                path: string;
            }[];
            exports: {
                type: "branch";
                branch: [string, import("./componentDefinition.js").ComponentExports][];
            };
            definitionType: {
                type: "app";
            } | {
                type: "childComponent";
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][];
            };
            httpMounts: Record<string, string>;
        }>;
        schema: z.ZodAny;
        functions: z.ZodRecord<z.ZodString, z.ZodObject<{
            functions: z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                pos: z.ZodAny;
                udfType: z.ZodUnion<[z.ZodLiteral<"Query">, z.ZodLiteral<"Mutation">, z.ZodLiteral<"Action">]>;
                visibility: z.ZodNullable<z.ZodUnion<[z.ZodObject<{
                    kind: z.ZodLiteral<"public">;
                }, "strip", z.ZodTypeAny, {
                    kind: "public";
                }, {
                    kind: "public";
                }>, z.ZodObject<{
                    kind: z.ZodLiteral<"internal">;
                }, "strip", z.ZodTypeAny, {
                    kind: "internal";
                }, {
                    kind: "internal";
                }>]>>;
                args: z.ZodNullable<z.ZodString>;
                returns: z.ZodNullable<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                args: string | null;
                returns: string | null;
                udfType: "Mutation" | "Action" | "Query";
                visibility: {
                    kind: "public";
                } | {
                    kind: "internal";
                } | null;
                pos?: any;
            }, {
                name: string;
                args: string | null;
                returns: string | null;
                udfType: "Mutation" | "Action" | "Query";
                visibility: {
                    kind: "public";
                } | {
                    kind: "internal";
                } | null;
                pos?: any;
            }>, "many">;
            httpRoutes: z.ZodAny;
            cronSpecs: z.ZodAny;
            sourceMapped: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            functions: {
                name: string;
                args: string | null;
                returns: string | null;
                udfType: "Mutation" | "Action" | "Query";
                visibility: {
                    kind: "public";
                } | {
                    kind: "internal";
                } | null;
                pos?: any;
            }[];
            httpRoutes?: any;
            cronSpecs?: any;
            sourceMapped?: any;
        }, {
            functions: {
                name: string;
                args: string | null;
                returns: string | null;
                udfType: "Mutation" | "Action" | "Query";
                visibility: {
                    kind: "public";
                } | {
                    kind: "internal";
                } | null;
                pos?: any;
            }[];
            httpRoutes?: any;
            cronSpecs?: any;
            sourceMapped?: any;
        }>>;
        udfConfig: z.ZodObject<{
            serverVersion: z.ZodString;
            importPhaseRngSeed: z.ZodAny;
            importPhaseUnixTimestamp: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            serverVersion: string;
            importPhaseRngSeed?: any;
            importPhaseUnixTimestamp?: any;
        }, {
            serverVersion: string;
            importPhaseRngSeed?: any;
            importPhaseUnixTimestamp?: any;
        }>;
    }, "strip", z.ZodTypeAny, {
        definition: {
            path: string;
            childComponents: {
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][] | null;
                path: string;
            }[];
            exports: {
                type: "branch";
                branch: [string, import("./componentDefinition.js").ComponentExports][];
            };
            definitionType: {
                type: "app";
            } | {
                type: "childComponent";
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][];
            };
            httpMounts: Record<string, string>;
        };
        functions: Record<string, {
            functions: {
                name: string;
                args: string | null;
                returns: string | null;
                udfType: "Mutation" | "Action" | "Query";
                visibility: {
                    kind: "public";
                } | {
                    kind: "internal";
                } | null;
                pos?: any;
            }[];
            httpRoutes?: any;
            cronSpecs?: any;
            sourceMapped?: any;
        }>;
        udfConfig: {
            serverVersion: string;
            importPhaseRngSeed?: any;
            importPhaseUnixTimestamp?: any;
        };
        schema?: any;
    }, {
        definition: {
            path: string;
            childComponents: {
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][] | null;
                path: string;
            }[];
            exports: {
                type: "branch";
                branch: [string, import("./componentDefinition.js").ComponentExports][];
            };
            definitionType: {
                type: "app";
            } | {
                type: "childComponent";
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][];
            };
            httpMounts: Record<string, string>;
        };
        functions: Record<string, {
            functions: {
                name: string;
                args: string | null;
                returns: string | null;
                udfType: "Mutation" | "Action" | "Query";
                visibility: {
                    kind: "public";
                } | {
                    kind: "internal";
                } | null;
                pos?: any;
            }[];
            httpRoutes?: any;
            cronSpecs?: any;
            sourceMapped?: any;
        }>;
        udfConfig: {
            serverVersion: string;
            importPhaseRngSeed?: any;
            importPhaseUnixTimestamp?: any;
        };
        schema?: any;
    }>>;
    app: z.ZodType<import("./checkedComponent.js").CheckedComponent, z.ZodTypeDef, import("./checkedComponent.js").CheckedComponent>;
    schemaChange: z.ZodObject<{
        allocatedComponentIds: z.ZodAny;
        schemaIds: z.ZodAny;
    }, "strip", z.ZodTypeAny, {
        allocatedComponentIds?: any;
        schemaIds?: any;
    }, {
        allocatedComponentIds?: any;
        schemaIds?: any;
    }>;
}, "strip", z.ZodTypeAny, {
    app: import("./checkedComponent.js").CheckedComponent;
    externalDepsId: string | null;
    componentDefinitionPackages: Record<string, any>;
    appAuth: {
        applicationID: string;
        domain: string;
    }[];
    analysis: Record<string, {
        definition: {
            path: string;
            childComponents: {
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][] | null;
                path: string;
            }[];
            exports: {
                type: "branch";
                branch: [string, import("./componentDefinition.js").ComponentExports][];
            };
            definitionType: {
                type: "app";
            } | {
                type: "childComponent";
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][];
            };
            httpMounts: Record<string, string>;
        };
        functions: Record<string, {
            functions: {
                name: string;
                args: string | null;
                returns: string | null;
                udfType: "Mutation" | "Action" | "Query";
                visibility: {
                    kind: "public";
                } | {
                    kind: "internal";
                } | null;
                pos?: any;
            }[];
            httpRoutes?: any;
            cronSpecs?: any;
            sourceMapped?: any;
        }>;
        udfConfig: {
            serverVersion: string;
            importPhaseRngSeed?: any;
            importPhaseUnixTimestamp?: any;
        };
        schema?: any;
    }>;
    schemaChange: {
        allocatedComponentIds?: any;
        schemaIds?: any;
    };
}, {
    app: import("./checkedComponent.js").CheckedComponent;
    externalDepsId: string | null;
    componentDefinitionPackages: Record<string, any>;
    appAuth: {
        applicationID: string;
        domain: string;
    }[];
    analysis: Record<string, {
        definition: {
            path: string;
            childComponents: {
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][] | null;
                path: string;
            }[];
            exports: {
                type: "branch";
                branch: [string, import("./componentDefinition.js").ComponentExports][];
            };
            definitionType: {
                type: "app";
            } | {
                type: "childComponent";
                name: string;
                args: [string, {
                    type: "value";
                    value: string;
                }][];
            };
            httpMounts: Record<string, string>;
        };
        functions: Record<string, {
            functions: {
                name: string;
                args: string | null;
                returns: string | null;
                udfType: "Mutation" | "Action" | "Query";
                visibility: {
                    kind: "public";
                } | {
                    kind: "internal";
                } | null;
                pos?: any;
            }[];
            httpRoutes?: any;
            cronSpecs?: any;
            sourceMapped?: any;
        }>;
        udfConfig: {
            serverVersion: string;
            importPhaseRngSeed?: any;
            importPhaseUnixTimestamp?: any;
        };
        schema?: any;
    }>;
    schemaChange: {
        allocatedComponentIds?: any;
        schemaIds?: any;
    };
}>;
export type StartPushResponse = z.infer<typeof startPushResponse>;
//# sourceMappingURL=startPush.d.ts.map