@oneclient/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,846 @@
+import { type AiRunRequest, type AnalyticsEvent, type ApiErrorCode, type CreateProjectRequest, type CreateProjectResponse, type CreatePreviewEnvironmentRequest, type CreatePreviewEnvironmentResponse, type Domain, type EmailSendRequest, type CreateOrganizationRequest, type CreateDeploymentRequest, type Deployment, type Organization, type Project, type QueryAst, type WalletSummary } from "@oneclient/contracts";
+import type { components, operations } from "@oneclient/contracts/openapi-types";
+export interface OneClientConfig {
+    baseUrl: string;
+    organizationId?: string;
+    publishableKey?: string;
+    serverKey?: string;
+    deployToken?: string;
+    session?: boolean;
+    fetch?: typeof globalThis.fetch;
+    headers?: Record<string, string>;
+}
+export interface OneClientRuntimeEnv {
+    ONECLIENT_API_URL: string;
+    ONECLIENT_SERVER_KEY: string;
+    ONECLIENT_ENVIRONMENT_ID?: string;
+    ONECLIENT_PROJECT_ID?: string;
+    ONECLIENT_DEPLOYMENT_ID?: string;
+}
+export interface ProjectAuthUser {
+    id: string;
+    name: string;
+    email: string;
+    emailVerified: boolean;
+    image: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ProjectAuthSession {
+    id: string;
+    userId: string;
+    token: string;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+    ipAddress: string | null;
+    userAgent: string | null;
+}
+export interface ProjectAuthSignIn {
+    token: string;
+    user: ProjectAuthUser;
+    session?: ProjectAuthSession;
+}
+export interface ProjectAuthSessionResult {
+    session: ProjectAuthSession;
+    user: ProjectAuthUser;
+    needsRefresh?: boolean;
+}
+export interface IdempotentRequestOptions {
+    idempotencyKey?: string;
+}
+export declare class OneClientError extends Error {
+    readonly code: ApiErrorCode;
+    readonly requestId: string;
+    readonly status: number;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: ApiErrorCode, message: string, requestId: string, status: number, details?: Record<string, unknown> | undefined);
+}
+type RequestOptions = {
+    body?: unknown;
+    headers?: Record<string, string>;
+    idempotent?: boolean;
+    method?: "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE";
+    rawBody?: BodyInit;
+};
+export type ServerKeyScope = "data:*" | "storage:*" | "kv:*" | "jobs:*" | "email:*" | "ai:*" | "analytics:*";
+export interface EnvironmentKey {
+    id: string;
+    prefix: "pk" | "sk" | "dp";
+    name: string;
+    scopes: string[];
+    lastFour: string;
+    createdAt: string;
+    lastUsedAt?: string | null;
+    expiresAt?: string | null;
+    revokedAt?: string | null;
+}
+export interface EnvironmentSecret {
+    id: string;
+    name: string;
+    version: number;
+    createdAt: string;
+    effectiveOnNextDeployment: boolean;
+}
+export type DataPolicyDocument = components["schemas"]["DataPolicyDocument"];
+export type DataPolicyMutation = components["schemas"]["DataPolicyMutation"];
+export type SqlExecuteInput = operations["executeSql"]["requestBody"]["content"]["application/json"];
+export type SqlExecuteResult = components["schemas"]["SqlResult"];
+export type DevelopmentInbox = components["schemas"]["DevelopmentInbox"];
+export type EnvironmentAuthOrigin = components["schemas"]["EnvironmentAuthOrigin"];
+export interface DeployTokenMutation {
+    id: string;
+    token: string;
+    shownOnce: true;
+}
+export interface GithubInstallation {
+    id: string;
+    accountLogin: string;
+    accountType: string;
+    repositorySelection: string;
+    status: "active" | "suspended" | "deleted";
+    updatedAt: string;
+}
+export interface GithubRepository {
+    id: string;
+    owner: string;
+    name: string;
+    fullName: string;
+    defaultBranch: string;
+    private: boolean;
+}
+export interface GithubLink {
+    id: string;
+    projectId: string;
+    installationId: string;
+    repositoryId: string;
+    repository: string;
+    productionEnvironmentId: string | null;
+    previewEnvironmentId: string;
+    productionBranch: string;
+    framework: "static" | "vite" | "next-opennext" | "worker";
+    rootDirectory: string | null;
+    entrypoint: string | null;
+    buildCommand: string | null;
+    outputDirectory: string | null;
+    lockfile: "pnpm" | "npm" | "yarn" | "bun" | null;
+    autoPromote: boolean;
+    previewsEnabled: boolean;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RegistrarContact {
+    email: string;
+    phone: string;
+    postal_info: {
+        name: string;
+        organization?: string;
+        address: {
+            street: string;
+            city: string;
+            state?: string;
+            postal_code: string;
+            country_code: string;
+        };
+    };
+}
+export interface RegistrarAttestation {
+    contactAccuracyConfirmed: true;
+    registrantAuthorityConfirmed: true;
+    registrationAgreementAccepted: true;
+    nonRefundableAcknowledged: true;
+    termsVersion: string;
+}
+export interface RegistrarQuote {
+    id: string;
+    domainName: string;
+    registrable: boolean;
+    reason?: string;
+    tier?: string;
+    currency?: string;
+    registrationCents?: number;
+    renewalEstimateCents?: number;
+    expiresAt?: string;
+    termsVersion: string;
+    replayed?: boolean;
+}
+export interface RegistrarOrder {
+    id: string;
+    domainName: string;
+    mode: "sandbox" | "live";
+    currency: string;
+    amountCents: number;
+    status: string;
+    providerState: string | null;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+    registeredAt: string | null;
+    refundedAt: string | null;
+}
+export interface RegistrarRegistration {
+    domainName: string;
+    orderId: string;
+    source: "provider" | "stored";
+    orderStatus: string;
+    providerStatus: string | null;
+    autoRenew: boolean | null;
+    locked: boolean | null;
+    privacyMode: "off" | "redaction" | null;
+    createdAt: string;
+    expiresAt: string | null;
+    registeredAt: string | null;
+    synchronizedAt: string | null;
+    capabilities: {
+        liveStatus: boolean;
+        autoRenewUpdate: false;
+        manualRenewal: false;
+        contactUpdate: false;
+        transferOut: false;
+    };
+}
+export type OrganizationRole = "owner" | "admin" | "developer" | "viewer";
+export interface OrganizationMember {
+    id: string;
+    role: OrganizationRole;
+    createdAt: string;
+    user: {
+        id: string;
+        name: string;
+        email: string;
+        image: string | null;
+    };
+}
+export interface OrganizationInvitation {
+    id: string;
+    email: string;
+    role: Exclude<OrganizationRole, "owner">;
+    status: string;
+    expiresAt: string;
+    createdAt: string;
+}
+export interface BillingSession {
+    id: string;
+    url: string;
+}
+export interface DeploymentUploadSession {
+    deploymentId: string;
+    status: "uploading" | "queued" | "building" | "ready" | "failed" | "promoted" | "superseded";
+    uploadUrl: string;
+    maximumBuildSeconds: number;
+    maximumBuildAttempts: number;
+    replayed?: boolean;
+}
+export interface RetentionExportComponent {
+    component: "d1" | "r2" | "kv";
+    status: "available" | "preparing" | "ready" | "downloaded" | "failed";
+    reservedMicros: string;
+    filename: string | null;
+    downloadExpiresAt: string | null;
+    downloadedAt: string | null;
+    errorCode: string | null;
+}
+export interface RetentionExportSession {
+    id: string;
+    organizationId: string;
+    projectId: string;
+    environmentId: string;
+    status: "available" | "complete" | "expired";
+    expiresAt: string;
+    createdAt: string;
+    replayed: boolean;
+    components: RetentionExportComponent[];
+}
+export interface D1RetentionExportResult {
+    id?: string;
+    component: "d1";
+    status: "preparing" | "ready";
+    filename?: string;
+    downloadUrl?: string;
+    downloadExpiresAt?: string;
+}
+export interface S3ObjectSummary {
+    key: string;
+    etag: string;
+    size: number;
+    lastModified: string;
+    storageClass: string;
+}
+export interface S3ObjectList {
+    name: string;
+    prefix: string;
+    keyCount: number;
+    maxKeys: number;
+    isTruncated: boolean;
+    nextContinuationToken: string | null;
+    commonPrefixes: string[];
+    contents: S3ObjectSummary[];
+}
+export interface S3ObjectMetadata {
+    etag: string;
+    contentLength: number;
+    lastModified: string;
+    storageClass: string;
+    contentType: string | null;
+}
+export interface S3MultipartUpload {
+    bucket: string;
+    key: string;
+    uploadId: string;
+}
+export interface S3UploadedPart {
+    partNumber: number;
+    etag: string;
+}
+export interface S3CompletedMultipartUpload extends S3MultipartUpload {
+    etag: string;
+}
+export interface S3BodyOptions extends IdempotentRequestOptions {
+    contentLength?: number;
+    contentType?: string;
+}
+export declare class OneClient {
+    private readonly baseUrl;
+    private readonly fetcher;
+    private readonly baseHeaders;
+    private readonly organizationId;
+    readonly auth: {
+        sendMagicLink: (input: {
+            email: string;
+            callbackURL?: string;
+            newUserCallbackURL?: string;
+        }, options?: IdempotentRequestOptions) => Promise<{
+            status: true;
+        }>;
+        sendOtp: (input: {
+            email: string;
+            type?: "sign-in";
+        }, options?: IdempotentRequestOptions) => Promise<{
+            success: true;
+        }>;
+        verifyOtp: (input: {
+            email: string;
+            otp: string;
+        }, options?: IdempotentRequestOptions) => Promise<ProjectAuthSignIn>;
+        getSession: () => Promise<ProjectAuthSessionResult | null>;
+        signOut: (options?: IdempotentRequestOptions) => Promise<{
+            success: true;
+        }>;
+    };
+    readonly account: {
+        me: () => Promise<{
+            user: {
+                id: string;
+                name: string;
+                email: string;
+                image: string | null;
+            };
+        }>;
+    };
+    readonly organizations: {
+        list: () => Promise<Organization[]>;
+        create: (input: CreateOrganizationRequest) => Promise<Organization>;
+        update: (organizationId: string, input: {
+            name: string;
+            slug: string;
+        }) => Promise<{
+            id: string;
+            name: string;
+            slug: string;
+            updated: true;
+        }>;
+        members: (organizationId: string) => Promise<{
+            members: OrganizationMember[];
+        }>;
+        updateMember: (organizationId: string, memberId: string, role: OrganizationRole) => Promise<{
+            id: string;
+            role: OrganizationRole;
+            replayed: boolean;
+        }>;
+        removeMember: (organizationId: string, memberId: string) => Promise<{
+            id: string;
+            removed: true;
+        }>;
+        invitations: (organizationId: string) => Promise<{
+            invitations: OrganizationInvitation[];
+        }>;
+        invite: (organizationId: string, email: string, role: OrganizationInvitation["role"]) => Promise<{
+            invitation: OrganizationInvitation;
+            replayed: boolean;
+        }>;
+        cancelInvitation: (organizationId: string, invitationId: string) => Promise<{
+            id: string;
+            status: "canceled";
+        }>;
+        acceptInvitation: (invitationId: string) => Promise<{
+            organizationId: string;
+            organizationName: string;
+            role: OrganizationInvitation["role"];
+            replayed: boolean;
+        }>;
+    };
+    readonly projects: {
+        list: () => Promise<Project[]>;
+        create: (input: CreateProjectRequest) => Promise<CreateProjectResponse>;
+        get: (projectId: string) => Promise<Project>;
+        createPreview: (projectId: string, input: CreatePreviewEnvironmentRequest) => Promise<CreatePreviewEnvironmentResponse>;
+        deletePreview: (environmentId: string) => Promise<{
+            environmentId: string;
+            operationId: string | null;
+            status: "deleting" | "deleted";
+            deletionDueAt: string;
+            replayed: boolean;
+        }>;
+        upgrade: (environmentId: string) => Promise<{
+            operationId: string;
+            status: string;
+            replayed: boolean;
+        }>;
+        retryProvisioning: (environmentId: string) => Promise<{
+            operationId: string;
+            status: string;
+            replayed: boolean;
+        }>;
+        cleanupOrphans: (environmentId: string) => Promise<{
+            operationId: string | null;
+            status: string;
+            replayed: boolean;
+        }>;
+    };
+    readonly authOrigins: {
+        list: (environmentId: string) => Promise<{
+            origins: EnvironmentAuthOrigin[];
+        }>;
+        create: (environmentId: string, origin: string) => Promise<{
+            origin: EnvironmentAuthOrigin;
+            replayed: boolean;
+        }>;
+        delete: (environmentId: string, originId: string) => Promise<{
+            id: string;
+            deletedAt: string;
+        }>;
+    };
+    readonly data: {
+        publishPolicy: (table: string, policy: DataPolicyDocument) => Promise<{
+            table: string;
+            version: number;
+            idempotencyKey: string;
+        }>;
+    };
+    readonly sql: {
+        execute: (input: SqlExecuteInput) => Promise<{
+            success: boolean;
+            meta: {
+                [key: string]: unknown;
+            };
+        }>;
+    };
+    readonly credentials: {
+        list: (environmentId: string) => Promise<{
+            keys: EnvironmentKey[];
+        }>;
+        create: (environmentId: string, input: {
+            prefix: "pk" | "sk";
+            name: string;
+            scopes?: ServerKeyScope[];
+            expiresAt?: string;
+        }) => Promise<{
+            key: EnvironmentKey;
+            token: string | null;
+            shownOnce: boolean;
+            replayed: boolean;
+        }>;
+        revoke: (environmentId: string, keyId: string) => Promise<{
+            id: string;
+            revokedAt: string;
+        }>;
+    };
+    readonly secrets: {
+        list: (environmentId: string) => Promise<{
+            secrets: EnvironmentSecret[];
+        }>;
+        put: (environmentId: string, name: string, value: string) => Promise<{
+            secret: EnvironmentSecret;
+            replayed: boolean;
+        }>;
+        delete: (environmentId: string, name: string) => Promise<{
+            name: string;
+            retiredAt: string;
+        }>;
+    };
+    readonly integrations: {
+        github: {
+            setup: (organizationId: string) => Promise<{
+                installUrl: string;
+                expiresAt: string;
+                replayed: boolean;
+            }>;
+            installations: (organizationId: string) => Promise<{
+                configured: boolean;
+                installations: GithubInstallation[];
+            }>;
+            repositories: (organizationId: string, installationId: string) => Promise<{
+                repositories: GithubRepository[];
+            }>;
+            links: (organizationId: string) => Promise<{
+                links: GithubLink[];
+            }>;
+            link: (input: {
+                organizationId: string;
+                projectId: string;
+                installationId: string;
+                repositoryId: string;
+                productionEnvironmentId?: string;
+                previewEnvironmentId: string;
+                productionBranch?: string;
+                framework: GithubLink["framework"];
+                rootDirectory?: string;
+                entrypoint?: string;
+                buildCommand?: string;
+                outputDirectory?: string;
+                lockfile?: Exclude<GithubLink["lockfile"], null>;
+                autoPromote?: boolean;
+                previewsEnabled?: boolean;
+            }) => Promise<{
+                id: string;
+                repository?: string;
+                replayed: boolean;
+            }>;
+            unlink: (linkId: string) => Promise<{
+                id: string;
+                active: false;
+                replayed: boolean;
+            }>;
+        };
+    };
+    readonly deployments: {
+        list: (environmentId: string) => Promise<Deployment[]>;
+        get: (deploymentId: string) => Promise<Deployment>;
+        create: (input: CreateDeploymentRequest) => Promise<DeploymentUploadSession>;
+        upload: (deploymentId: string, archive: BodyInit, input: {
+            artifactDigest: string;
+            contentLength: number;
+        }) => Promise<{
+            deploymentId: string;
+            status: string;
+            replay?: boolean;
+        }>;
+        logs: (deploymentId: string) => Promise<string>;
+        promote: (deploymentId: string) => Promise<{
+            deploymentId: string;
+            status: "promoted";
+        }>;
+    };
+    readonly deployTokens: {
+        create: (input: {
+            environmentId: string;
+            name: string;
+            expiresAt?: string;
+        }) => Promise<DeployTokenMutation>;
+    };
+    readonly retentionExports: {
+        create: (environmentId: string) => Promise<RetentionExportSession>;
+        get: (sessionId: string) => Promise<RetentionExportSession>;
+        prepareD1: (sessionId: string) => Promise<D1RetentionExportResult>;
+        download: (sessionId: string, component: "r2" | "kv") => Promise<Response>;
+    };
+    readonly billing: {
+        subscriptionCheckout: () => Promise<BillingSession>;
+        topupCheckout: (amountMicros: string) => Promise<BillingSession>;
+        portal: () => Promise<BillingSession>;
+    };
+    readonly registrar: {
+        quote: (domainName: string) => Promise<RegistrarQuote>;
+        checkout: (input: {
+            quoteId: string;
+            confirmDomainName: string;
+            registrant: RegistrarContact;
+            attestation: RegistrarAttestation;
+        }) => Promise<{
+            id: string;
+            url: string;
+            orderId: string;
+            replayed: boolean;
+        }>;
+        orders: () => Promise<{
+            configured: boolean;
+            mode: "disabled" | "sandbox" | "live";
+            orders: RegistrarOrder[];
+        }>;
+        registration: (domainName: string) => Promise<RegistrarRegistration>;
+    };
+    readonly storage: {
+        get: (bucket: string, key: string) => Promise<Response>;
+        put: (bucket: string, key: string, body: BodyInit, contentType?: string) => Promise<Response>;
+        delete: (bucket: string, key: string) => Promise<Response>;
+        signedUrl: (input: {
+            bucket: string;
+            key: string;
+            operation: "get" | "put";
+            expiresInSeconds: number;
+            contentLength?: number;
+        }) => Promise<{
+            url: string;
+            expiresAt: string;
+        }>;
+    };
+    readonly s3: {
+        list: (bucket: string, options?: IdempotentRequestOptions & {
+            prefix?: string;
+            delimiter?: string;
+            continuationToken?: string;
+            maxKeys?: number;
+        }) => Promise<S3ObjectList>;
+        get: (bucket: string, key: string, options?: IdempotentRequestOptions & {
+            range?: string;
+        }) => Promise<Response>;
+        head: (bucket: string, key: string, options?: IdempotentRequestOptions) => Promise<S3ObjectMetadata>;
+        put: (bucket: string, key: string, body: BodyInit, options?: S3BodyOptions) => Promise<{
+            bucket: string;
+            key: string;
+            etag: string;
+        }>;
+        delete: (bucket: string, key: string, options?: IdempotentRequestOptions) => Promise<void>;
+        initiateMultipart: (bucket: string, key: string, options?: IdempotentRequestOptions & {
+            contentType?: string;
+        }) => Promise<S3MultipartUpload>;
+        uploadPart: (bucket: string, key: string, uploadId: string, partNumber: number, body: BodyInit, options?: S3BodyOptions) => Promise<S3UploadedPart>;
+        completeMultipart: (bucket: string, key: string, uploadId: string, parts: ReadonlyArray<S3UploadedPart>, options?: IdempotentRequestOptions) => Promise<S3CompletedMultipartUpload>;
+        abortMultipart: (bucket: string, key: string, uploadId: string, options?: IdempotentRequestOptions) => Promise<void>;
+    };
+    readonly kv: {
+        get: <T = unknown>(key: string) => Promise<{
+            value: T;
+            consistency: "eventual";
+        }>;
+        put: (key: string, value: unknown, expirationTtl?: number) => Promise<{
+            success: true;
+            consistency: "eventual";
+        }>;
+        delete: (key: string) => Promise<void>;
+    };
+    readonly jobs: {
+        enqueue: (queue: string, payload: unknown, delaySeconds?: number) => Promise<{
+            jobId: string;
+        }>;
+        list: () => Promise<{
+            jobs: unknown[];
+        }>;
+        deadLetter: () => Promise<{
+            jobs: unknown[];
+        }>;
+        retry: (jobId: string) => Promise<{
+            jobId: string;
+            retriedFrom: string;
+        }>;
+        schedules: () => Promise<{
+            schedules: unknown[];
+        }>;
+        schedule: (input: {
+            name: string;
+            cron: string;
+            queue: string;
+            payload: unknown;
+        }) => Promise<{
+            id: string;
+            nextRunAt: string;
+        }>;
+        deleteSchedule: (scheduleId: string) => Promise<void>;
+    };
+    readonly email: {
+        send: (input: EmailSendRequest) => Promise<{
+            messageId?: string;
+            status: "suppressed" | "captured" | "queued";
+            accepted: number;
+            suppressed: number;
+            inbox?: string;
+            reservationIds?: string[];
+        }>;
+        developmentInbox: () => Promise<{
+            messages: {
+                [key: string]: unknown;
+            }[];
+        }>;
+        templates: () => Promise<{
+            templates: unknown[];
+        }>;
+        saveTemplate: (input: {
+            name: string;
+            subject: string;
+            text?: string;
+            html?: string;
+        }) => Promise<{
+            id: string;
+            name: string;
+            version: number;
+        }>;
+        deleteTemplate: (templateId: string) => Promise<void>;
+        logs: () => Promise<{
+            logs: unknown[];
+        }>;
+        suppressions: () => Promise<{
+            suppressions: unknown[];
+        }>;
+        suppress: (email: string, reason?: string) => Promise<{
+            addressHash: string;
+            suppressed: true;
+        }>;
+        unsuppress: (addressHash: string) => Promise<void>;
+        webhooks: () => Promise<{
+            endpoints: unknown[];
+        }>;
+        createWebhook: (url: string, events?: string[]) => Promise<{
+            id: string;
+            url: string;
+            events: string[];
+            secret: string;
+            shownOnce: true;
+        }>;
+        deleteWebhook: (endpointId: string) => Promise<void>;
+    };
+    readonly ai: {
+        models: () => Promise<{
+            models: Array<{
+                id: string;
+                name: string;
+                task: string;
+                provider: string;
+                pricing: Record<string, unknown>;
+                capabilities: Record<string, unknown>;
+            }>;
+        }>;
+        run: <T = unknown>(input: Omit<AiRunRequest, "gateway"> & {
+            gateway?: AiRunRequest["gateway"];
+        }) => Promise<{
+            output: T;
+            gateway?: "byok";
+            usage?: {
+                inputTokens: number;
+                outputTokens: number;
+                neurons: number;
+            };
+            reservationId: string;
+        }>;
+        connections: () => Promise<{
+            connections: unknown[];
+        }>;
+        connect: (input: {
+            provider: "openai-compatible";
+            name: string;
+            baseUrl: string;
+            apiKey: string;
+            allowedModels: string[];
+        }) => Promise<unknown>;
+        disconnect: (connectionId: string) => Promise<void>;
+    };
+    readonly analytics: {
+        track: (events: AnalyticsEvent[]) => Promise<{
+            accepted: number;
+            duplicates: number;
+        }>;
+        timeseries: (input?: {
+            from?: string;
+            to?: string;
+            interval?: "hour" | "day";
+            event?: string;
+        }) => Promise<unknown>;
+        users: (input?: {
+            from?: string;
+            to?: string;
+        }) => Promise<unknown>;
+        sessions: (input?: {
+            from?: string;
+            to?: string;
+        }) => Promise<unknown>;
+        export: (input: {
+            from: string;
+            to: string;
+            format?: "ndjson" | "csv";
+        }) => Promise<unknown>;
+        downloadExport: (exportId: string) => Promise<Response>;
+        funnel: (input: {
+            events: string[];
+            from: string;
+            to: string;
+            windowSeconds?: number;
+        }) => Promise<unknown>;
+        retention: (input: {
+            startEvent: string;
+            returnEvent: string;
+            from: string;
+            to: string;
+        }) => Promise<unknown>;
+    };
+    readonly domains: {
+        list: () => Promise<Domain[]>;
+        add: (input: {
+            environmentId: string;
+            hostname: string;
+            purpose: "app" | "api" | "sending";
+        }) => Promise<Domain>;
+        refresh: (domainId: string) => Promise<unknown>;
+        remove: (domainId: string) => Promise<void>;
+    };
+    readonly usage: {
+        summary: () => Promise<WalletSummary>;
+        timeseries: (days?: number) => Promise<{
+            usage: Array<{
+                day: string;
+                amountMicros: string;
+            }>;
+        }>;
+        activity: (limit?: number) => Promise<{
+            events: Array<{
+                id: string;
+                title: string;
+                detail: string;
+                at: string;
+                tone: string;
+            }>;
+        }>;
+    };
+    constructor(config: OneClientConfig);
+    from(table: string): DataQueryBuilder;
+    private requireOrganizationId;
+    executeQuery(query: QueryAst): Promise<{
+        rows: Array<Record<string, unknown>>;
+        meta: {
+            rowsRead: number;
+            usageEventId: string;
+        };
+    }>;
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    rawRequest(path: string, options?: RequestOptions): Promise<Response>;
+}
+export declare class DataQueryBuilder {
+    private readonly client;
+    private readonly query;
+    constructor(client: OneClient, table: string, query?: QueryAst);
+    select(...fields: string[]): DataQueryBuilder;
+    eq(field: string, value: unknown): DataQueryBuilder;
+    in(field: string, values: unknown[]): DataQueryBuilder;
+    filter(field: string, op: QueryAst["filters"][number]["op"], value?: unknown): DataQueryBuilder;
+    order(field: string, direction?: "asc" | "desc"): DataQueryBuilder;
+    limit(limit: number): DataQueryBuilder;
+    range(offset: number, limit: number): DataQueryBuilder;
+    execute(): Promise<{
+        rows: Array<Record<string, unknown>>;
+        meta: {
+            rowsRead: number;
+            usageEventId: string;
+        };
+    }>;
+    insert(record: Record<string, unknown>, maxStorageDeltaBytes: number): Promise<unknown>;
+    update(values: Record<string, unknown>, options: {
+        maxRows: number;
+        maxStorageDeltaBytes: number;
+    }): Promise<unknown>;
+    delete(maxRows: number): Promise<unknown>;
+    toJSON(): QueryAst;
+    private with;
+}
+export declare function createClient(config: OneClientConfig): OneClient;
+export declare function createServerClient(env: OneClientRuntimeEnv, config?: Omit<OneClientConfig, "baseUrl" | "publishableKey" | "serverKey">): OneClient;
+export {};
+//# sourceMappingURL=index.d.ts.map