@oneclient/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,648 @@
+import { aiRunRequestSchema, analyticsEventSchema, apiErrorSchema, createOrganizationRequestSchema, createPreviewEnvironmentRequestSchema, createPreviewEnvironmentResponseSchema, createDeploymentRequestSchema, createProjectRequestSchema, createProjectResponseSchema, dataQueryResponseSchema, deploymentSchema, domainSchema, emailSendRequestSchema, organizationSchema, projectSchema, queryAstSchema, walletSummarySchema, } from "@oneclient/contracts";
+function idempotencyRequestOptions(options) {
+    return options?.idempotencyKey ? { headers: { "Idempotency-Key": options.idempotencyKey } } : {};
+}
+export class OneClientError extends Error {
+    code;
+    requestId;
+    status;
+    details;
+    constructor(code, message, requestId, status, details) {
+        super(message);
+        this.code = code;
+        this.requestId = requestId;
+        this.status = status;
+        this.details = details;
+        this.name = "OneClientError";
+    }
+}
+export class OneClient {
+    baseUrl;
+    fetcher;
+    baseHeaders;
+    organizationId;
+    auth = {
+        sendMagicLink: (input, options) => this.request("/v1/auth/sign-in/magic-link", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+            ...idempotencyRequestOptions(options),
+        }),
+        sendOtp: (input, options) => this.request("/v1/auth/email-otp/send-verification-otp", {
+            method: "POST",
+            body: { type: "sign-in", ...input },
+            idempotent: true,
+            ...idempotencyRequestOptions(options),
+        }),
+        verifyOtp: (input, options) => this.request("/v1/auth/sign-in/email-otp", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+            ...idempotencyRequestOptions(options),
+        }),
+        getSession: async () => {
+            const session = await this.request("/v1/auth/get-session");
+            if (!session?.needsRefresh)
+                return session;
+            return this.request("/v1/auth/get-session", {
+                method: "POST",
+                idempotent: true,
+            });
+        },
+        signOut: (options) => this.request("/v1/auth/sign-out", {
+            method: "POST",
+            idempotent: true,
+            ...idempotencyRequestOptions(options),
+        }),
+    };
+    account = {
+        me: () => this.request("/v1/me"),
+    };
+    organizations = {
+        list: async () => {
+            const response = await this.request("/v1/organizations");
+            return organizationSchema.array().parse(response.organizations);
+        },
+        create: async (input) => {
+            const response = await this.request("/v1/organizations", {
+                method: "POST",
+                body: createOrganizationRequestSchema.parse(input),
+                idempotent: true,
+            });
+            return organizationSchema.parse(response.organization);
+        },
+        update: (organizationId, input) => this.request(`/v1/organizations/${encodeURIComponent(organizationId)}`, { method: "PATCH", body: input, idempotent: true }),
+        members: (organizationId) => this.request(`/v1/organizations/${encodeURIComponent(organizationId)}/members`),
+        updateMember: (organizationId, memberId, role) => this.request(`/v1/organizations/${encodeURIComponent(organizationId)}/members/${encodeURIComponent(memberId)}`, { method: "PATCH", body: { role }, idempotent: true }),
+        removeMember: (organizationId, memberId) => this.request(`/v1/organizations/${encodeURIComponent(organizationId)}/members/${encodeURIComponent(memberId)}`, { method: "DELETE", idempotent: true }),
+        invitations: (organizationId) => this.request(`/v1/organizations/${encodeURIComponent(organizationId)}/invitations`),
+        invite: (organizationId, email, role) => this.request(`/v1/organizations/${encodeURIComponent(organizationId)}/invitations`, { method: "POST", body: { email, role }, idempotent: true }),
+        cancelInvitation: (organizationId, invitationId) => this.request(`/v1/organizations/${encodeURIComponent(organizationId)}/invitations/${encodeURIComponent(invitationId)}`, { method: "DELETE", idempotent: true }),
+        acceptInvitation: (invitationId) => this.request(`/v1/invitations/${encodeURIComponent(invitationId)}/accept`, { method: "POST" }),
+    };
+    projects = {
+        list: async () => {
+            const organizationId = this.requireOrganizationId();
+            const value = await this.request(`/v1/projects?organizationId=${encodeURIComponent(organizationId)}`);
+            return projectSchema.array().parse(value.projects);
+        },
+        create: async (input) => {
+            const body = createProjectRequestSchema.parse(input);
+            return createProjectResponseSchema.parse(await this.request("/v1/projects", { method: "POST", body, idempotent: true }));
+        },
+        get: async (projectId) => projectSchema.parse(await this.request(`/v1/projects/${encodeURIComponent(projectId)}`)),
+        createPreview: async (projectId, input) => {
+            const body = createPreviewEnvironmentRequestSchema.parse(input);
+            return createPreviewEnvironmentResponseSchema.parse(await this.request(`/v1/projects/${encodeURIComponent(projectId)}/preview-environments`, {
+                method: "POST",
+                body,
+                idempotent: true,
+            }));
+        },
+        deletePreview: (environmentId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+        upgrade: (environmentId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/upgrade`, { method: "POST", idempotent: true }),
+        retryProvisioning: (environmentId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/retry-provisioning`, { method: "POST", idempotent: true }),
+        cleanupOrphans: (environmentId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/cleanup-orphans`, { method: "POST", idempotent: true }),
+    };
+    authOrigins = {
+        list: (environmentId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/auth/origins`),
+        create: (environmentId, origin) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/auth/origins`, { method: "POST", body: { origin } }),
+        delete: (environmentId, originId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/auth/origins/${encodeURIComponent(originId)}`, { method: "DELETE" }),
+    };
+    data = {
+        publishPolicy: (table, policy) => this.request("/v1/data/policies", {
+            method: "POST",
+            body: { table, policy },
+            idempotent: true,
+        }),
+    };
+    sql = {
+        execute: (input) => this.request("/v1/sql", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        }),
+    };
+    credentials = {
+        list: (environmentId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/keys`),
+        create: (environmentId, input) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/keys`, {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        }),
+        revoke: (environmentId, keyId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/keys/${encodeURIComponent(keyId)}`, { method: "DELETE" }),
+    };
+    secrets = {
+        list: (environmentId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/secrets`),
+        put: (environmentId, name, value) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/secrets/${encodeURIComponent(name)}`, { method: "PUT", body: { value }, idempotent: true }),
+        delete: (environmentId, name) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/secrets/${encodeURIComponent(name)}`, { method: "DELETE" }),
+    };
+    integrations = {
+        github: {
+            setup: (organizationId) => this.request("/v1/integrations/github/setup", { method: "POST", body: { organizationId }, idempotent: true }),
+            installations: (organizationId) => this.request(`/v1/integrations/github/installations?organizationId=${encodeURIComponent(organizationId)}`),
+            repositories: (organizationId, installationId) => this.request(`/v1/integrations/github/repositories?organizationId=${encodeURIComponent(organizationId)}&installationId=${encodeURIComponent(installationId)}`),
+            links: (organizationId) => this.request(`/v1/integrations/github/links?organizationId=${encodeURIComponent(organizationId)}`),
+            link: (input) => this.request("/v1/integrations/github/links", { method: "POST", body: input, idempotent: true }),
+            unlink: (linkId) => this.request(`/v1/integrations/github/links/${encodeURIComponent(linkId)}`, { method: "DELETE", idempotent: true }),
+        },
+    };
+    deployments = {
+        list: async (environmentId) => {
+            const response = await this.request(`/v1/deployments?environmentId=${encodeURIComponent(environmentId)}`);
+            return deploymentSchema.array().parse(response.deployments);
+        },
+        get: async (deploymentId) => deploymentSchema.parse(await this.request(`/v1/deployments/${encodeURIComponent(deploymentId)}`)),
+        create: (input) => this.request("/v1/deployments", {
+            method: "POST",
+            body: createDeploymentRequestSchema.parse(input),
+            idempotent: true,
+        }),
+        upload: (deploymentId, archive, input) => this.request(`/v1/deployments/${encodeURIComponent(deploymentId)}/artifact`, {
+            method: "PUT",
+            rawBody: archive,
+            headers: {
+                "Content-Type": "application/x-tar",
+                "Content-Length": String(input.contentLength),
+                "X-Artifact-SHA256": input.artifactDigest,
+            },
+            idempotent: true,
+        }),
+        logs: async (deploymentId) => (await this.rawRequest(`/v1/deployments/${encodeURIComponent(deploymentId)}/logs`)).text(),
+        promote: (deploymentId) => this.request(`/v1/deployments/${encodeURIComponent(deploymentId)}/promote`, { method: "POST", idempotent: true }),
+    };
+    deployTokens = {
+        create: (input) => this.request("/v1/deploy-tokens", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        }),
+    };
+    retentionExports = {
+        create: (environmentId) => this.request(`/v1/environments/${encodeURIComponent(environmentId)}/retention-exports`, { method: "POST", idempotent: true }),
+        get: (sessionId) => this.request(`/v1/retention-exports/${encodeURIComponent(sessionId)}`),
+        prepareD1: (sessionId) => this.request(`/v1/retention-exports/${encodeURIComponent(sessionId)}/components/d1`, { method: "POST", idempotent: true }),
+        download: (sessionId, component) => this.rawRequest(`/v1/retention-exports/${encodeURIComponent(sessionId)}/components/${component}/download`, { method: "POST", idempotent: true }),
+    };
+    billing = {
+        subscriptionCheckout: () => {
+            const organizationId = this.requireOrganizationId();
+            return this.request("/v1/billing/subscription-checkout", {
+                method: "POST",
+                body: { organizationId },
+                idempotent: true,
+            });
+        },
+        topupCheckout: (amountMicros) => {
+            const organizationId = this.requireOrganizationId();
+            return this.request("/v1/billing/topup-checkout", {
+                method: "POST",
+                body: { organizationId, amountMicros },
+                idempotent: true,
+            });
+        },
+        portal: () => {
+            const organizationId = this.requireOrganizationId();
+            return this.request("/v1/billing/portal", {
+                method: "POST",
+                body: { organizationId },
+                idempotent: true,
+            });
+        },
+    };
+    registrar = {
+        quote: (domainName) => {
+            const organizationId = this.requireOrganizationId();
+            return this.request("/v1/registrar/quotes", {
+                method: "POST",
+                body: { organizationId, domainName },
+                idempotent: true,
+            });
+        },
+        checkout: (input) => {
+            const organizationId = this.requireOrganizationId();
+            return this.request("/v1/registrar/checkout", { method: "POST", body: { organizationId, ...input }, idempotent: true });
+        },
+        orders: () => {
+            const organizationId = this.requireOrganizationId();
+            return this.request(`/v1/registrar/orders?organizationId=${encodeURIComponent(organizationId)}`);
+        },
+        registration: (domainName) => {
+            const organizationId = this.requireOrganizationId();
+            return this.request(`/v1/registrar/registrations/${encodeURIComponent(domainName)}?organizationId=${encodeURIComponent(organizationId)}`);
+        },
+    };
+    storage = {
+        get: (bucket, key) => this.rawRequest(`/v1/storage/${encodeURIComponent(bucket)}/${encodePath(key)}`),
+        put: (bucket, key, body, contentType = "application/octet-stream") => this.rawRequest(`/v1/storage/${encodeURIComponent(bucket)}/${encodePath(key)}`, {
+            method: "PUT",
+            rawBody: body,
+            idempotent: true,
+            headers: { "Content-Type": contentType },
+        }),
+        delete: (bucket, key) => this.rawRequest(`/v1/storage/${encodeURIComponent(bucket)}/${encodePath(key)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+        signedUrl: (input) => this.request("/v1/storage/signed-url", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        }),
+    };
+    s3 = {
+        list: (bucket, options = {}) => {
+            const query = queryString({
+                prefix: options.prefix,
+                delimiter: options.delimiter,
+                "continuation-token": options.continuationToken,
+                "max-keys": options.maxKeys,
+            });
+            return this.request(`/v1/s3/${encodeURIComponent(bucket)}${query ? `?${query}` : ""}`, { idempotent: true, ...idempotencyRequestOptions(options) });
+        },
+        get: (bucket, key, options = {}) => this.rawRequest(`/v1/s3/${encodeURIComponent(bucket)}/${encodePath(key)}`, {
+            idempotent: true,
+            headers: {
+                ...(options.range ? { Range: options.range } : {}),
+                ...(options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : {}),
+            },
+        }),
+        head: async (bucket, key, options = {}) => {
+            const response = await this.rawRequest(`/v1/s3/${encodeURIComponent(bucket)}/${encodePath(key)}`, {
+                method: "HEAD",
+                idempotent: true,
+                ...idempotencyRequestOptions(options),
+            });
+            return {
+                etag: response.headers.get("ETag") ?? "",
+                contentLength: Number(response.headers.get("Content-Length") ?? "0"),
+                lastModified: response.headers.get("Last-Modified") ?? "",
+                storageClass: response.headers.get("X-OneClient-Storage-Class") ?? "",
+                contentType: response.headers.get("Content-Type"),
+            };
+        },
+        put: (bucket, key, body, options = {}) => this.request(`/v1/s3/${encodeURIComponent(bucket)}/${encodePath(key)}`, {
+            method: "PUT",
+            rawBody: body,
+            idempotent: true,
+            headers: {
+                "Content-Type": options.contentType ?? "application/octet-stream",
+                "Content-Length": String(resolveBodyLength(body, options.contentLength)),
+                ...(options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : {}),
+            },
+        }),
+        delete: (bucket, key, options = {}) => this.request(`/v1/s3/${encodeURIComponent(bucket)}/${encodePath(key)}`, {
+            method: "DELETE",
+            idempotent: true,
+            ...idempotencyRequestOptions(options),
+        }),
+        initiateMultipart: (bucket, key, options = {}) => this.request(`/v1/s3/${encodeURIComponent(bucket)}/${encodePath(key)}?uploads=`, {
+            method: "POST",
+            idempotent: true,
+            headers: {
+                ...(options.contentType ? { "Content-Type": options.contentType } : {}),
+                ...(options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : {}),
+            },
+        }),
+        uploadPart: (bucket, key, uploadId, partNumber, body, options = {}) => this.request(`/v1/s3/${encodeURIComponent(bucket)}/${encodePath(key)}?${queryString({ uploadId, partNumber })}`, {
+            method: "PUT",
+            rawBody: body,
+            idempotent: true,
+            headers: {
+                "Content-Type": options.contentType ?? "application/octet-stream",
+                "Content-Length": String(resolveBodyLength(body, options.contentLength)),
+                ...(options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : {}),
+            },
+        }),
+        completeMultipart: (bucket, key, uploadId, parts, options = {}) => this.request(`/v1/s3/${encodeURIComponent(bucket)}/${encodePath(key)}?${queryString({ uploadId })}`, {
+            method: "POST",
+            body: { parts: parts.map((part) => ({ ...part })) },
+            idempotent: true,
+            ...idempotencyRequestOptions(options),
+        }),
+        abortMultipart: (bucket, key, uploadId, options = {}) => this.request(`/v1/s3/${encodeURIComponent(bucket)}/${encodePath(key)}?${queryString({ uploadId })}`, {
+            method: "DELETE",
+            idempotent: true,
+            ...idempotencyRequestOptions(options),
+        }),
+    };
+    kv = {
+        get: (key) => this.request(`/v1/kv/${encodeURIComponent(key)}`),
+        put: (key, value, expirationTtl) => this.request(`/v1/kv/${encodeURIComponent(key)}`, {
+            method: "PUT",
+            body: { value, expirationTtl },
+            idempotent: true,
+        }),
+        delete: (key) => this.request(`/v1/kv/${encodeURIComponent(key)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+    };
+    jobs = {
+        enqueue: (queue, payload, delaySeconds = 0) => this.request(`/v1/jobs/${encodeURIComponent(queue)}`, {
+            method: "POST",
+            body: { payload, delaySeconds },
+            idempotent: true,
+        }),
+        list: () => this.request("/v1/jobs"),
+        deadLetter: () => this.request("/v1/jobs/dead-letter"),
+        retry: (jobId) => this.request(`/v1/jobs/${encodeURIComponent(jobId)}/retry`, { method: "POST", idempotent: true }),
+        schedules: () => this.request("/v1/jobs/schedules"),
+        schedule: (input) => this.request("/v1/jobs/schedules", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        }),
+        deleteSchedule: (scheduleId) => this.request(`/v1/jobs/schedules/${encodeURIComponent(scheduleId)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+    };
+    email = {
+        send: (input) => this.request("/v1/email/send", {
+            method: "POST",
+            body: emailSendRequestSchema.parse(input),
+            idempotent: true,
+        }),
+        developmentInbox: () => this.request("/v1/email/development-inbox"),
+        templates: () => this.request("/v1/email/templates"),
+        saveTemplate: (input) => this.request("/v1/email/templates", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        }),
+        deleteTemplate: (templateId) => this.request(`/v1/email/templates/${encodeURIComponent(templateId)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+        logs: () => this.request("/v1/email/logs"),
+        suppressions: () => this.request("/v1/email/suppressions"),
+        suppress: (email, reason) => this.request("/v1/email/suppressions", {
+            method: "POST",
+            body: { email, reason },
+            idempotent: true,
+        }),
+        unsuppress: (addressHash) => this.request(`/v1/email/suppressions/${encodeURIComponent(addressHash)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+        webhooks: () => this.request("/v1/email/webhooks"),
+        createWebhook: (url, events = ["email.*"]) => this.request("/v1/email/webhooks", {
+            method: "POST",
+            body: { url, events },
+            idempotent: true,
+        }),
+        deleteWebhook: (endpointId) => this.request(`/v1/email/webhooks/${encodeURIComponent(endpointId)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+    };
+    ai = {
+        models: () => this.request("/v1/ai/models"),
+        run: (input) => this.request("/v1/ai/run", {
+            method: "POST",
+            body: aiRunRequestSchema.parse(input),
+            idempotent: true,
+        }),
+        connections: () => this.request("/v1/ai/connections"),
+        connect: (input) => this.request("/v1/ai/connections", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        }),
+        disconnect: (connectionId) => this.request(`/v1/ai/connections/${encodeURIComponent(connectionId)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+    };
+    analytics = {
+        track: (events) => this.request("/v1/analytics/events", {
+            method: "POST",
+            body: { events: events.map((event) => analyticsEventSchema.parse(event)) },
+            idempotent: true,
+        }),
+        timeseries: (input = {}) => this.request(`/v1/analytics/timeseries?${queryString(input)}`),
+        users: (input = {}) => this.request(`/v1/analytics/users?${queryString(input)}`),
+        sessions: (input = {}) => this.request(`/v1/analytics/sessions?${queryString(input)}`),
+        export: (input) => this.request("/v1/analytics/exports", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        }),
+        downloadExport: (exportId) => this.rawRequest(`/v1/analytics/exports/${encodeURIComponent(exportId)}`),
+        funnel: (input) => this.request("/v1/analytics/funnels", { method: "POST", body: input }),
+        retention: (input) => this.request("/v1/analytics/retention", { method: "POST", body: input }),
+    };
+    domains = {
+        list: async () => {
+            const organizationId = this.requireOrganizationId();
+            const value = await this.request(`/v1/domains?organizationId=${encodeURIComponent(organizationId)}`);
+            return domainSchema.array().parse(value.domains);
+        },
+        add: async (input) => domainSchema.parse(await this.request("/v1/domains", {
+            method: "POST",
+            body: input,
+            idempotent: true,
+        })),
+        refresh: (domainId) => this.request(`/v1/domains/${encodeURIComponent(domainId)}/refresh`, {
+            method: "POST",
+            idempotent: true,
+        }),
+        remove: (domainId) => this.request(`/v1/domains/${encodeURIComponent(domainId)}`, {
+            method: "DELETE",
+            idempotent: true,
+        }),
+    };
+    usage = {
+        summary: async () => {
+            const organizationId = this.requireOrganizationId();
+            return walletSummarySchema.parse(await this.request(`/v1/usage?organizationId=${encodeURIComponent(organizationId)}`));
+        },
+        timeseries: (days = 14) => {
+            const organizationId = this.requireOrganizationId();
+            return this.request(`/v1/usage/timeseries?organizationId=${encodeURIComponent(organizationId)}&days=${encodeURIComponent(String(days))}`);
+        },
+        activity: (limit = 20) => {
+            const organizationId = this.requireOrganizationId();
+            return this.request(`/v1/activity?organizationId=${encodeURIComponent(organizationId)}&limit=${encodeURIComponent(String(limit))}`);
+        },
+    };
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.organizationId = config.organizationId;
+        this.fetcher = config.fetch ?? globalThis.fetch.bind(globalThis);
+        this.baseHeaders = { Accept: "application/json", ...config.headers };
+        if (config.publishableKey)
+            this.baseHeaders["X-OneClient-Key"] = config.publishableKey;
+        if (config.serverKey)
+            this.baseHeaders.Authorization = `Bearer ${config.serverKey}`;
+        if (config.deployToken)
+            this.baseHeaders.Authorization = `Bearer ${config.deployToken}`;
+        if (!config.publishableKey && !config.serverKey && !config.deployToken && !config.session) {
+            throw new TypeError("OneClient requires a publishableKey, serverKey, deployToken, or session mode");
+        }
+    }
+    from(table) {
+        return new DataQueryBuilder(this, table);
+    }
+    requireOrganizationId() {
+        if (!this.organizationId)
+            throw new TypeError("This operation requires organizationId in OneClientConfig");
+        return this.organizationId;
+    }
+    async executeQuery(query) {
+        return dataQueryResponseSchema.parse(await this.request("/v1/data/query", {
+            method: "POST",
+            body: { query: queryAstSchema.parse(query) },
+        }));
+    }
+    async request(path, options = {}) {
+        const response = await this.rawRequest(path, options);
+        if (response.status === 204)
+            return undefined;
+        return (await response.json());
+    }
+    async rawRequest(path, options = {}) {
+        const headers = new Headers({ ...this.baseHeaders, ...options.headers });
+        if (options.idempotent && !headers.has("Idempotency-Key")) {
+            headers.set("Idempotency-Key", `idem_${crypto.randomUUID()}`);
+        }
+        let body = options.rawBody;
+        if (options.body !== undefined) {
+            headers.set("Content-Type", "application/json");
+            body = JSON.stringify(options.body);
+        }
+        const response = await this.fetcher(`${this.baseUrl}${path}`, {
+            method: options.method ?? "GET",
+            headers,
+            ...(body === undefined ? {} : { body }),
+            credentials: "include",
+        });
+        if (!response.ok) {
+            let payload;
+            try {
+                payload = await response.json();
+            }
+            catch {
+                payload = undefined;
+            }
+            const parsed = apiErrorSchema.safeParse(payload);
+            if (parsed.success) {
+                throw new OneClientError(parsed.data.error.code, parsed.data.error.message, parsed.data.error.requestId, response.status, parsed.data.error.details);
+            }
+            throw new OneClientError("INTERNAL_ERROR", `OneClient request failed with status ${response.status}`, response.headers.get("X-Request-Id") ?? "unknown", response.status);
+        }
+        return response;
+    }
+}
+function queryString(input) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(input))
+        if (value !== undefined)
+            search.set(key, String(value));
+    return search.toString();
+}
+function resolveBodyLength(body, supplied) {
+    if (supplied !== undefined) {
+        if (!Number.isSafeInteger(supplied) || supplied < 0)
+            throw new TypeError("contentLength must be a non-negative safe integer");
+        return supplied;
+    }
+    if (typeof body === "string")
+        return new TextEncoder().encode(body).byteLength;
+    if (body instanceof ArrayBuffer)
+        return body.byteLength;
+    if (ArrayBuffer.isView(body))
+        return body.byteLength;
+    if (typeof Blob !== "undefined" && body instanceof Blob)
+        return body.size;
+    if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams)
+        return new TextEncoder().encode(body.toString()).byteLength;
+    throw new TypeError("contentLength is required for streamed S3 request bodies");
+}
+export class DataQueryBuilder {
+    client;
+    query;
+    constructor(client, table, query) {
+        this.client = client;
+        this.query = query ?? {
+            table,
+            select: ["id"],
+            filters: [],
+            orderBy: [],
+            limit: 100,
+            offset: 0,
+        };
+    }
+    select(...fields) {
+        return this.with({ select: fields });
+    }
+    eq(field, value) {
+        return this.filter(field, "eq", value);
+    }
+    in(field, values) {
+        return this.filter(field, "in", values);
+    }
+    filter(field, op, value) {
+        return this.with({
+            filters: [...this.query.filters, value === undefined ? { field, op } : { field, op, value }],
+        });
+    }
+    order(field, direction = "asc") {
+        return this.with({ orderBy: [...this.query.orderBy, { field, direction }] });
+    }
+    limit(limit) {
+        return this.with({ limit });
+    }
+    range(offset, limit) {
+        return this.with({ offset, limit });
+    }
+    execute() {
+        return this.client.executeQuery(this.query);
+    }
+    insert(record, maxStorageDeltaBytes) {
+        return this.client.request("/v1/data/insert", {
+            method: "POST",
+            body: { table: this.query.table, record, maxStorageDeltaBytes },
+            idempotent: true,
+        });
+    }
+    update(values, options) {
+        return this.client.request("/v1/data/update", {
+            method: "PATCH",
+            body: { table: this.query.table, values, filters: this.query.filters, ...options },
+            idempotent: true,
+        });
+    }
+    delete(maxRows) {
+        return this.client.request("/v1/data/delete", {
+            method: "DELETE",
+            body: { table: this.query.table, filters: this.query.filters, maxRows },
+            idempotent: true,
+        });
+    }
+    toJSON() {
+        return structuredClone(this.query);
+    }
+    with(patch) {
+        return new DataQueryBuilder(this.client, this.query.table, { ...this.query, ...patch });
+    }
+}
+function encodePath(value) {
+    return value.split("/").map(encodeURIComponent).join("/");
+}
+export function createClient(config) {
+    return new OneClient(config);
+}
+export function createServerClient(env, config = {}) {
+    if (!env.ONECLIENT_API_URL || !env.ONECLIENT_SERVER_KEY)
+        throw new TypeError("Managed OneClient runtime bindings are unavailable");
+    return new OneClient({
+        ...config,
+        baseUrl: env.ONECLIENT_API_URL,
+        serverKey: env.ONECLIENT_SERVER_KEY,
+    });
+}