@contember/client 1.0.0-rc.2 → 1.0.0-rc.4

package/dist/client.d.ts

@@ -1,716 +0,0 @@
-declare type CreateMutationArguments = 'data';
-
-declare type CreateMutationFields = 'ok' | 'validation' | 'errors' | 'errorMessage' | 'node';
-
-declare namespace CrudQueryBuilder {
-    export {
-        CrudQueryBuilder_2 as CrudQueryBuilder,
-        ReadBuilder,
-        Mutations,
-        Queries,
-        GetQueryArguments,
-        ListQueryArguments,
-        PaginateQueryArguments,
-        CreateMutationArguments,
-        UpdateMutationArguments,
-        DeleteMutationArguments,
-        ReductionArguments,
-        HasOneArguments,
-        HasManyArguments,
-        UpdateMutationFields,
-        CreateMutationFields,
-        DeleteMutationFields,
-        WriteArguments,
-        WriteFields,
-        ReadArguments,
-        WriteRelationOps,
-        OrderDirection,
-        WriteOperation,
-        WriteBuilder,
-        WriteDataBuilder,
-        WriteManyRelationBuilder,
-        WriteOneRelationBuilder
-    }
-}
-export { CrudQueryBuilder }
-
-declare class CrudQueryBuilder_2 {
-    private type;
-    private rootObjectBuilder;
-    constructor(type?: undefined | 'query' | 'mutation', rootObjectBuilder?: RootObjectBuilder);
-    fragment(name: string, typeName: string, query: ReadBuilder.BuilderFactory<never>): CrudQueryBuilder_2;
-    list(name: string, query: ReadBuilder.BuilderFactory<ListQueryArguments>, alias?: string): Omit<CrudQueryBuilder_2, Mutations>;
-    paginate(name: string, query: ReadBuilder.BuilderFactory<PaginateQueryArguments>, alias?: string): Omit<CrudQueryBuilder_2, Mutations>;
-    get(name: string, query: ReadBuilder.BuilderFactory<GetQueryArguments>, alias?: string): Omit<CrudQueryBuilder_2, Mutations>;
-    update(name: string, query: WriteBuilder.BuilderFactory<UpdateMutationArguments, UpdateMutationFields, WriteOperation.Update>, alias?: string): Omit<CrudQueryBuilder_2, Queries>;
-    create(name: string, query: WriteBuilder.BuilderFactory<CreateMutationArguments, CreateMutationFields, WriteOperation.Create>, alias?: string): Omit<CrudQueryBuilder_2, Queries>;
-    delete(name: string, query: WriteBuilder.BuilderFactory<DeleteMutationArguments, DeleteMutationFields, WriteOperation.Delete>, alias?: string): Omit<CrudQueryBuilder_2, Queries>;
-    inTransaction(alias?: string, options?: {
-        deferForeignKeyConstraints?: boolean;
-    }): CrudQueryBuilder_2;
-    getGql(): string;
-}
-
-declare type DeleteMutationArguments = 'by';
-
-declare type DeleteMutationFields = 'ok' | 'node' | 'errors' | 'errorMessage';
-
-export declare interface FileUploader<Result = any, Error extends FileUploadError = FileUploadError> {
-    upload: (files: Map<File, UploadedFileMetadata>, options: FileUploaderInitializeOptions<Result, Error>) => Promise<void>;
-    destroy?: (files: Result[]) => Promise<void>;
-}
-
-export declare interface FileUploaderInitializeOptions<Result = any, Error extends FileUploadError = FileUploadError> {
-    contentApiClient: GraphQlClient;
-    onSuccess: (result: Iterable<[File, Result]>) => void;
-    onError: (error: Iterable<File | [File, Error]>) => void;
-    onProgress: (progress: Iterable<[File, FileUploadProgress]>) => void;
-}
-
-export declare class FileUploadError extends Error {
-    readonly options: FileUploadErrorOptions;
-    constructor(options?: FileUploadErrorOptions);
-}
-
-export declare interface FileUploadErrorOptions {
-    developerMessage?: string;
-    endUserMessage?: string;
-}
-
-export declare interface FileUploadProgress {
-    progress?: number;
-}
-
-export declare const formatContentApiRelativeUrl: (projectSlug: string, stageSlug: string) => string;
-
-export declare const formatSystemApiRelativeUrl: (projectSlug: string) => string;
-
-export declare class GenerateUploadUrlMutationBuilder {
-    private static generateUploadUrlFields;
-    static buildQuery(parameters: GenerateUploadUrlMutationBuilder.MutationParameters): string;
-}
-
-export declare namespace GenerateUploadUrlMutationBuilder {
-    export interface FileParameters {
-        contentType: string;
-        expiration?: number;
-        prefix?: string;
-        acl?: GraphQlLiteral<'PUBLIC_READ' | 'PRIVATE' | 'NONE'>;
-    }
-    export interface MutationParameters {
-        [alias: string]: FileParameters;
-    }
-    export interface ResponseBody {
-        url: string;
-        publicUrl: string;
-        method: string;
-        headers: Array<{
-            key: string;
-            value: string;
-        }>;
-    }
-    export interface MutationResponse {
-        [alias: string]: ResponseBody;
-    }
-}
-
-declare type GetQueryArguments = 'by';
-
-export declare const getTenantErrorMessage: (errorCode: string) => string;
-
-declare namespace GraphQlBuilder {
-    export {
-        GraphQlLiteral,
-        ObjectBuilder,
-        QueryBuilder,
-        QueryCompiler,
-        RootObjectBuilder
-    }
-}
-export { GraphQlBuilder }
-
-export declare class GraphQlClient {
-    readonly apiUrl: string;
-    private readonly apiToken?;
-    constructor(apiUrl: string, apiToken?: string | undefined);
-    sendRequest<T = any>(query: string, { apiTokenOverride, signal, variables, headers }?: GraphQlClientRequestOptions): Promise<T>;
-}
-
-export declare type GraphQlClientFailedRequestMetadata = Pick<Response, 'status' | 'statusText'> & {
-    responseText: string;
-};
-
-export declare interface GraphQlClientRequestOptions {
-    variables?: GraphQlClientVariables;
-    apiTokenOverride?: string;
-    signal?: AbortSignal;
-    headers?: Record<string, string>;
-}
-
-export declare interface GraphQlClientVariables {
-    [name: string]: any;
-}
-
-export declare class GraphQlLiteral<Value extends string = string> {
-    readonly value: Value;
-    constructor(value: Value);
-    toString(): string;
-}
-
-declare type HasManyArguments = 'filter' | 'orderBy' | 'offset' | 'limit';
-
-declare type HasOneArguments = 'filter';
-
-export declare namespace Input {
-    export type PrimaryValue<E = never> = Value.PrimaryValue<E>;
-    export type ColumnValue<E = never> = Value.FieldValue<E>;
-    export enum UpdateRelationOperation {
-        connect = "connect",
-        disconnect = "disconnect",
-        create = "create",
-        update = "update",
-        upsert = "upsert",
-        delete = "delete"
-    }
-    export enum CreateRelationOperation {
-        connect = "connect",
-        create = "create"
-    }
-    export interface ConnectRelationInput<E = never> {
-        connect: UniqueWhere<E>;
-    }
-    export interface CreateRelationInput<E = never> {
-        create: CreateDataInput<E>;
-    }
-    export interface DisconnectSpecifiedRelationInput<E = never> {
-        disconnect: UniqueWhere<E>;
-    }
-    export interface DeleteSpecifiedRelationInput<E = never> {
-        delete: UniqueWhere<E>;
-    }
-    export interface UpdateSpecifiedRelationInput<E = never> {
-        update: {
-            by: UniqueWhere<E>;
-            data: UpdateDataInput<E>;
-        };
-    }
-    export interface UpsertSpecifiedRelationInput<E = never> {
-        upsert: {
-            by: UniqueWhere<E>;
-            update: UpdateDataInput<E>;
-            create: CreateDataInput<E>;
-        };
-    }
-    export interface DisconnectRelationInput {
-        disconnect: true;
-    }
-    export interface UpdateRelationInput<E = never> {
-        update: UpdateDataInput<E>;
-    }
-    export interface DeleteRelationInput {
-        delete: true;
-    }
-    export interface UpsertRelationInput<E = never> {
-        upsert: {
-            update: UpdateDataInput<E>;
-            create: CreateDataInput<E>;
-        };
-    }
-    export interface CreateDataInput<E = never> {
-        [column: string]: Value.FieldValue<E> | CreateOneRelationInput<E> | CreateManyRelationInput<E>;
-    }
-    export type CreateOneRelationInput<E = never> = {
-        alias?: string;
-    } & (ConnectRelationInput<E> | CreateRelationInput<E>);
-    export type CreateManyRelationInput<E = never> = Array<CreateOneRelationInput<E>>;
-    export interface UpdateDataInput<E = never> {
-        [column: string]: Value.FieldValue<E> | UpdateOneRelationInput<E> | UpdateManyRelationInput<E>;
-    }
-    export interface UpdateInput<E = never> {
-        by: UniqueWhere<E>;
-        filter?: OptionalWhere<E>;
-        data: UpdateDataInput<E>;
-    }
-    export interface CreateInput<E = never> {
-        data: CreateDataInput<E>;
-    }
-    export interface DeleteInput<E = never> {
-        by: UniqueWhere<E>;
-        filter?: OptionalWhere<E>;
-    }
-    export interface UniqueQueryInput<E = never> {
-        by: UniqueWhere<E>;
-        filter?: OptionalWhere<E>;
-    }
-    export interface ListQueryInput<E = never> {
-        filter?: OptionalWhere<E>;
-        orderBy?: OrderBy[];
-        offset?: number;
-        limit?: number;
-    }
-    export interface PaginationQueryInput<E = never> {
-        filter?: OptionalWhere<E>;
-        orderBy?: OrderBy[];
-        skip?: number;
-        first?: number;
-    }
-    /** @deprecated */
-    export type SelectQueryInput<E = never> = PaginationQueryInput<E>;
-    export type UpdateOneRelationInput<E = never> = CreateRelationInput<E> | ConnectRelationInput<E> | DeleteRelationInput | DisconnectRelationInput | UpdateRelationInput<E> | UpsertRelationInput<E>;
-    export type UpdateManyRelationInputItem<E = never> = {
-        alias?: string;
-    } & (CreateRelationInput<E> | ConnectRelationInput<E> | DeleteSpecifiedRelationInput<E> | DisconnectSpecifiedRelationInput<E> | UpdateSpecifiedRelationInput<E> | UpsertSpecifiedRelationInput<E>);
-    export type UpdateManyRelationInput<E = never> = Array<UpdateManyRelationInputItem<E>>;
-    export enum OrderDirection {
-        asc = "asc",
-        desc = "desc"
-    }
-    export type FieldOrderBy<T = OrderDirection> = T | OrderBy<T>;
-    export interface OrderByFields<T = OrderDirection> {
-        [fieldName: string]: FieldOrderBy<T>;
-    }
-    export type OrderBy<T = OrderDirection> = OrderByFields<T> & {
-        _random?: boolean;
-        _randomSeeded?: number;
-    };
-    export interface Condition<T = Value.FieldValue> {
-        and?: Array<Condition<T>>;
-        or?: Array<Condition<T>>;
-        not?: Condition<T>;
-        eq?: T;
-        null?: boolean;
-        isNull?: boolean;
-        notEq?: T;
-        in?: T[];
-        notIn?: T[];
-        lt?: T;
-        lte?: T;
-        gt?: T;
-        gte?: T;
-        never?: true;
-        always?: true;
-        contains?: string;
-        startsWith?: string;
-        endsWith?: string;
-        containsCI?: string;
-        startsWithCI?: string;
-        endsWithCI?: string;
-    }
-    export interface UniqueWhere<E = never> {
-        [field: string]: Value.PrimaryValue<E> | UniqueWhere<E>;
-    }
-    export type ComposedWhere<C, Opt = never> = {
-        and?: (Where<C, Opt> | Opt)[];
-        or?: (Where<C, Opt> | Opt)[];
-        not?: Where<C, Opt>;
-    };
-    export interface FieldWhere<C = Condition, Opt = never> {
-        [name: string]: C | Where<C, Opt> | undefined | (Where<C, Opt> | Opt)[];
-    }
-    export type Where<C = Condition, Opt = never> = ComposedWhere<C, Opt> & FieldWhere<C, Opt>;
-    export type OptionalWhere<E = never> = Where<Condition<Value.FieldValue<E>>, null | undefined>;
-    export enum FieldMeta {
-        readable = "readable",
-        updatable = "updatable"
-    }
-}
-
-declare type ListQueryArguments = 'filter' | 'orderBy' | 'offset' | 'limit';
-
-export declare const loginMutation = "\n\tmutation($email: String!, $password: String!, $expiration: Int) {\n\t\tsignIn(email: $email, password: $password, expiration: $expiration) {\n\t\t\tok\n\t\t\terrors {\n\t\t\t\tendUserMessage\n\t\t\t\tcode\n\t\t\t}\n\t\t\tresult {\n\t\t\t\ttoken\n\t\t\t\tperson {\n\t\t\t\t\tid\n\t\t\t\t\temail\n\t\t\t\t\tidentity {\n\t\t\t\t\t\tid\n\t\t\t\t\t\tprojects {\n\t\t\t\t\t\t\tproject {\n\t\t\t\t\t\t\t\tid\n\t\t\t\t\t\t\t\tslug\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tmemberships {\n\t\t\t\t\t\t\t\trole\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n";
-
-export declare interface LoginMutationResponse {
-    data: {
-        signIn: {
-            ok: boolean;
-            errors: Array<{
-                endUserMessage: string | null;
-                code: string;
-            }>;
-            result: {
-                token: string;
-                person: {
-                    id: string;
-                    email: string;
-                    identity: {
-                        id: string;
-                        projects: Array<{
-                            project: {
-                                id: string;
-                                slug: string;
-                            };
-                            memberships: Array<{
-                                role: string;
-                            }>;
-                        }>;
-                    };
-                };
-            } | null;
-        };
-    };
-}
-
-declare type Mutations = 'create' | 'update' | 'delete';
-
-declare class ObjectBuilder {
-    readonly fields: string[];
-    readonly objects: {
-        [name: string]: ObjectBuilder;
-    };
-    readonly args: {
-        [name: string]: any;
-    };
-    readonly fragmentApplications: string[];
-    readonly inlineFragments: {
-        [typeName: string]: ObjectBuilder;
-    };
-    readonly objectName?: string | undefined;
-    constructor(fields?: string[], objects?: {
-        [name: string]: ObjectBuilder;
-    }, args?: {
-        [name: string]: any;
-    }, fragmentApplications?: string[], inlineFragments?: {
-        [typeName: string]: ObjectBuilder;
-    }, objectName?: string | undefined);
-    argument(name: string, value: any): ObjectBuilder;
-    name(name: string): ObjectBuilder;
-    field(name: string): ObjectBuilder;
-    object(name: string, builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder): ObjectBuilder;
-    inlineFragment(typeName: string, builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder): ObjectBuilder;
-    applyFragment(fragmentName: string): ObjectBuilder;
-}
-
-declare type OrderDirection = GraphQlBuilder.GraphQlLiteral<'asc'> | GraphQlBuilder.GraphQlLiteral<'desc'>;
-
-declare type PaginateQueryArguments = 'filter' | 'orderBy' | 'skip' | 'first';
-
-declare type Queries = 'get' | 'list' | 'paginate';
-
-declare class QueryBuilder {
-    query(builder: ((builder: RootObjectBuilder) => RootObjectBuilder) | RootObjectBuilder): string;
-    mutation(builder: ((builder: RootObjectBuilder) => RootObjectBuilder) | RootObjectBuilder): string;
-}
-
-declare namespace QueryBuilder {
-    interface Object {
-        [key: string]: Value;
-    }
-    interface List extends Array<Value> {
-    }
-    type AtomicValue = string | null | number | boolean | GraphQlLiteral;
-    type Value = AtomicValue | QueryBuilder.Object | List;
-}
-
-declare class QueryCompiler {
-    private operation;
-    private builder;
-    constructor(operation: 'query' | 'mutation', builder: RootObjectBuilder);
-    create(): string;
-    private formatFragmentDefinitions;
-    private formatRootObjects;
-    private formatObject;
-    private formatObjectBody;
-    private formatArgs;
-}
-
-declare type ReadArguments = GetQueryArguments | ListQueryArguments | PaginateQueryArguments | HasOneArguments | HasManyArguments;
-
-declare class ReadBuilder<AllowedArgs extends ReadArguments = ReadArguments> {
-    readonly objectBuilder: ObjectBuilder;
-    protected constructor(objectBuilder?: ObjectBuilder);
-    static instantiate<AllowedArgs extends ReadArguments = ReadArguments>(objectBuilder?: ObjectBuilder): ReadBuilder.Builder<AllowedArgs>;
-    static instantiateFromFactory<AllowedArgs extends ReadArguments>(builder: ReadBuilder.BuilderFactory<AllowedArgs>): ReadBuilder.Builder<never>;
-    protected instantiate<AA extends ReadArguments = ReadArguments>(objectBuilder?: ObjectBuilder): ReadBuilder.Builder<AA>;
-    by(by: Input.UniqueWhere<GraphQlLiteral>): ReadBuilder.Builder<Exclude<AllowedArgs, "by">>;
-    filter(where: Input.Where<Input.Condition<Input.ColumnValue<GraphQlLiteral>>>): ReadBuilder.Builder<Exclude<AllowedArgs, "filter">>;
-    orderBy(orderBy: Input.OrderBy<OrderDirection>[]): ReadBuilder.Builder<Exclude<AllowedArgs, "orderBy">>;
-    offset(offset: number): ReadBuilder.Builder<Exclude<AllowedArgs, "offset">>;
-    limit(limit: number): ReadBuilder.Builder<Exclude<AllowedArgs, "limit">>;
-    skip(offset: number): ReadBuilder.Builder<Exclude<AllowedArgs, "skip">>;
-    first(limit: number): ReadBuilder.Builder<Exclude<AllowedArgs, "first">>;
-    column(name: string): ReadBuilder.Builder<AllowedArgs>;
-    inlineFragment(typeName: string, builder: ReadBuilder.BuilderFactory<never>): ReadBuilder.Builder<AllowedArgs>;
-    applyFragment(fragmentName: string): ReadBuilder.Builder<AllowedArgs>;
-    reductionRelation(name: string, builder: ReadBuilder.BuilderFactory<ReductionArguments>, alias?: string): ReadBuilder.Builder<AllowedArgs>;
-    hasOneRelation(name: string, builder: ReadBuilder.BuilderFactory<HasOneArguments>, alias?: string): ReadBuilder.Builder<AllowedArgs>;
-    hasManyRelation(name: string, builder: ReadBuilder.BuilderFactory<HasManyArguments>, alias?: string): ReadBuilder.Builder<AllowedArgs>;
-    anyRelation(name: string, builder: ReadBuilder.BuilderFactory<never>, alias?: string): ReadBuilder.Builder<AllowedArgs>;
-    protected relation<A extends ReadArguments>(name: string, builder: ReadBuilder.BuilderFactory<A>, alias?: string): ReadBuilder.Builder<AllowedArgs>;
-}
-
-declare namespace ReadBuilder {
-    type Builder<AllowedArgs extends ReadArguments> = Omit<ReadBuilder<AllowedArgs>, Exclude<ReadArguments, AllowedArgs>>;
-    type BuilderFactory<AllowedArgs extends ReadArguments> = Builder<never> | ((builder: Builder<AllowedArgs>) => Builder<never>);
-}
-
-declare type ReductionArguments = 'filter' | 'by';
-
-export declare interface RelationFilter {
-    name: string;
-    relations: RelationFilter[];
-}
-
-export declare namespace Result {
-    export type MutationFieldResult = CreateResult | UpdateResult | DeleteResult;
-    export interface CreateResult {
-        ok: boolean;
-        errorMessage?: string;
-        errors: ExecutionError[];
-        validation: ValidationResult;
-        node: Value.Object | null;
-    }
-    export interface UpdateResult {
-        ok: boolean;
-        errorMessage?: string;
-        errors: ExecutionError[];
-        validation: ValidationResult;
-        node: Value.Object | null;
-    }
-    export interface DeleteResult {
-        ok: boolean;
-        errorMessage?: string;
-        errors: ExecutionError[];
-        node: Value.Object | null;
-    }
-    export interface TransactionResult {
-        ok: boolean;
-        errorMessage?: string;
-        errors: ExecutionError[];
-        validation: ValidationResult;
-    }
-    export interface ValidationResult {
-        valid: boolean;
-        errors: ValidationError[];
-    }
-    export interface ValidationError {
-        path: PathFragment[];
-        message: ValidationMessage;
-    }
-    export enum ExecutionErrorType {
-        NotNullConstraintViolation = "NotNullConstraintViolation",
-        UniqueConstraintViolation = "UniqueConstraintViolation",
-        ForeignKeyConstraintViolation = "ForeignKeyConstraintViolation",
-        NotFoundOrDenied = "NotFoundOrDenied",
-        NonUniqueWhereInput = "NonUniqueWhereInput",
-        InvalidDataInput = "InvalidDataInput",
-        SqlError = "SqlError"
-    }
-    export interface ExecutionError {
-        /** @deprecated */
-        path: PathFragment[];
-        paths: PathFragment[][];
-        type: ExecutionErrorType;
-        message?: string;
-    }
-    export type PathFragment = {
-        field: string;
-    } | {
-        index: number;
-        alias?: string;
-    };
-    export interface ValidationMessage {
-        text: string;
-    }
-}
-
-declare class RootObjectBuilder {
-    readonly objects: {
-        [name: string]: ObjectBuilder;
-    };
-    readonly fragmentDefinitions: {
-        [name: string]: ObjectBuilder;
-    };
-    constructor(objects?: {
-        [name: string]: ObjectBuilder;
-    }, fragmentDefinitions?: {
-        [name: string]: ObjectBuilder;
-    });
-    fragment(name: string, builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder): RootObjectBuilder;
-    object(name: string, builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder): RootObjectBuilder;
-}
-
-export declare class S3FileUploader implements FileUploader<S3FileUploader.SuccessMetadata> {
-    readonly options: S3FileUploader.Options;
-    private readonly uploadState;
-    constructor(options?: S3FileUploader.Options);
-    private generateNewAlias;
-    private static formatFullAlias;
-    upload(files: Map<File, UploadedFileMetadata>, { contentApiClient, onSuccess, onError, onProgress }: FileUploaderInitializeOptions): Promise<void>;
-}
-
-export declare namespace S3FileUploader {
-    export interface SuccessMetadata {
-        fileUrl: string;
-    }
-    export interface Options {
-        getUploadOptions?: (file: File) => S3UploadOptions;
-    }
-    export interface S3UploadOptions {
-        fileExpiration?: GenerateUploadUrlMutationBuilder.FileParameters['expiration'];
-        filePrefix?: GenerateUploadUrlMutationBuilder.FileParameters['prefix'];
-        fileAcl?: GenerateUploadUrlMutationBuilder.FileParameters['acl'];
-    }
-}
-
-export declare interface SystemEvent {
-    id: string;
-    createdAt: string;
-    type: 'CREATE' | 'UPDATE' | 'DELETE';
-    dependencies: string[];
-    description: string;
-    identityDescription: string;
-    transactionId: string;
-}
-
-export declare const tenantApiRelativeUrl = "/tenant";
-
-export declare const tenantErrorMessages: {
-    [key: string]: string;
-};
-
-export declare interface TreeFilter {
-    entity: string;
-    id: string;
-    relations: RelationFilter[];
-}
-
-declare type UpdateMutationArguments = 'data' | 'by';
-
-declare type UpdateMutationFields = 'ok' | 'validation' | 'errors' | 'errorMessage' | 'node';
-
-export declare interface UploadedFileMetadata {
-    abortSignal: AbortSignal;
-}
-
-export declare namespace Value {
-    export interface Object<E = never> {
-        [key: string]: FieldValue<E>;
-    }
-    export interface List<E = never> extends Array<FieldValue<E>> {
-    }
-    export type PrimaryValue<E = never> = string | number | E;
-    export type AtomicValue<E = never> = PrimaryValue<E> | null | boolean;
-    export type FieldValue<E = never> = AtomicValue<E> | Value.Object<E> | List<E>;
-    export type GenericValueLike<T> = T | PromiseLike<T> | (() => T | PromiseLike<T>);
-    export type ColumnValueLike<E = never> = GenericValueLike<FieldValue<E>>;
-}
-
-export declare const whereToFilter: (by: Input.UniqueWhere<GraphQlLiteral>) => Input.Where<Input.Condition<Input.ColumnValue<GraphQlLiteral>>>;
-
-declare type WriteArguments = CreateMutationArguments | UpdateMutationArguments | DeleteMutationArguments;
-
-declare class WriteBuilder<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation> {
-    readonly objectBuilder: ObjectBuilder;
-    protected constructor(objectBuilder?: ObjectBuilder);
-    static instantiate<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation>(objectBuilder?: ObjectBuilder): WriteBuilder.Builder<AA, AF, Op>;
-    static instantiateFromFactory<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation>(builder: WriteBuilder.BuilderFactory<AA, AF, Op>): WriteBuilder.Builder<never, never, Op>;
-    data<SubOp extends Op & WriteOperation.ContentfulOperation>(data: WriteDataBuilder.DataLike<SubOp>): WriteBuilder.Builder<Exclude<AA, "data">, AF, Op>;
-    by(by: Input.UniqueWhere<GraphQlLiteral>): WriteBuilder.Builder<Exclude<AA, "by">, AF, Op>;
-    ok(): WriteBuilder.Builder<AA, Exclude<AF, "ok">, Op>;
-    errorMessage(): WriteBuilder.Builder<AA, Exclude<AF, "errorMessage">, Op>;
-    validation(): WriteBuilder.Builder<AA, Exclude<AF, "validation">, Op>;
-    errors(): WriteBuilder.Builder<AA, Exclude<AF, "errors">, Op>;
-    node(builder: ReadBuilder.BuilderFactory<never>): WriteBuilder.Builder<AA, Exclude<AF, "node">, Op>;
-}
-
-declare namespace WriteBuilder {
-    type Builder<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation> = Omit<Omit<WriteBuilder<AA, AF, Op>, Exclude<WriteArguments, AA>>, Exclude<WriteFields, AF>>;
-    type BuilderFactory<AA extends WriteArguments, AF extends WriteFields, Op extends WriteOperation.Operation> = Builder<never, never, Op> | ((builder: Builder<AA, AF, Op>) => Builder<never, never, Op>);
-}
-
-declare class WriteDataBuilder<Op extends WriteOperation.ContentfulOperation> {
-    readonly data: WriteDataBuilder.DataFormat[Op['op']];
-    constructor(data?: WriteDataBuilder.DataFormat[Op['op']]);
-    static resolveData<Op extends WriteOperation.ContentfulOperation>(dataLike: WriteDataBuilder.DataLike<Op>): WriteDataBuilder.DataFormat[Op['op']] | undefined;
-    set(fieldName: string, value: Input.ColumnValue<GraphQlLiteral>): WriteDataBuilder<Op>;
-    many(fieldName: string, data: WriteManyRelationBuilder.BuilderFactory<Op>): WriteDataBuilder<Op>;
-    one(fieldName: string, data: WriteOneRelationBuilder.BuilderFactory<Op>): WriteDataBuilder<Op>;
-    private mergeInFreshData;
-    private mergeUpdateOne;
-}
-
-declare namespace WriteDataBuilder {
-    interface DataFormat {
-        create: Input.CreateDataInput<GraphQlLiteral>;
-        update: Input.UpdateDataInput<GraphQlLiteral>;
-    }
-    type DataLike<Op extends WriteOperation.ContentfulOperation> = DataFormat[Op['op']] | WriteDataBuilder<Op> | ((builder: WriteDataBuilder<Op>) => WriteDataBuilder<Op>);
-}
-
-declare type WriteFields = UpdateMutationFields | CreateMutationFields;
-
-declare class WriteManyRelationBuilder<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']]> {
-    readonly data: WriteManyRelationBuilder.DataFormat[Op['op']];
-    private constructor();
-    static instantiate<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']]>(data?: WriteManyRelationBuilder.DataFormat[Op['op']]): WriteManyRelationBuilder.Builder<Op, Allowed>;
-    static instantiateFromFactory<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']]>(builder: WriteManyRelationBuilder.BuilderFactory<Op, Allowed>): WriteManyRelationBuilder.Builder<Op, never>;
-    create(data: WriteDataBuilder.DataLike<WriteOperation.Create>, alias?: string): WriteManyRelationBuilder.Builder<Op>;
-    connect(where: Input.UniqueWhere<GraphQlLiteral>, alias?: string): WriteManyRelationBuilder.Builder<Op, WriteRelationOps[Op["op"]]>;
-    delete(where: Input.UniqueWhere<GraphQlLiteral>, alias?: string): WriteManyRelationBuilder.Builder<WriteOperation.Update, "create" | "update" | "delete" | "connect" | "disconnect" | "upsert">;
-    disconnect(where: Input.UniqueWhere<GraphQlLiteral>, alias?: string): WriteManyRelationBuilder.Builder<WriteOperation.Update, "create" | "update" | "delete" | "connect" | "disconnect" | "upsert">;
-    update(where: Input.UniqueWhere<GraphQlLiteral>, data: WriteDataBuilder.DataLike<WriteOperation.Update>, alias?: string): WriteManyRelationBuilder.Builder<WriteOperation.Update>;
-    upsert(where: Input.UniqueWhere<GraphQlLiteral>, update: WriteDataBuilder.DataLike<WriteOperation.Update>, create: WriteDataBuilder.DataLike<WriteOperation.Create>, alias?: string): WriteManyRelationBuilder.Builder<WriteOperation.Update>;
-    private withAlias;
-}
-
-declare namespace WriteManyRelationBuilder {
-    interface DataFormat {
-        create: Input.CreateManyRelationInput<GraphQlLiteral>;
-        update: Input.UpdateManyRelationInput<GraphQlLiteral>;
-    }
-    type Builder<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']]> = Omit<WriteManyRelationBuilder<Op, Allowed>, Exclude<WriteRelationOps[WriteOperation.ContentfulOperation['op']], Allowed>>;
-    type BuilderFactory<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']]> = DataFormat[Op['op']] | Builder<Op, never> | ((builder: Builder<Op, Allowed>) => Builder<Op, never>);
-}
-
-declare class WriteOneRelationBuilder<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']], D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']]> {
-    readonly data: D;
-    protected constructor(data?: D);
-    static instantiate<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']], D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']]>(data?: D): WriteOneRelationBuilder.Builder<Op, Allowed, D>;
-    static instantiateFromFactory<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']], D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']]>(builder: WriteOneRelationBuilder.BuilderFactory<Op, Allowed, D>): WriteOneRelationBuilder.Builder<Op, never, D>;
-    create(data: WriteDataBuilder.DataLike<WriteOperation.Create>): this | WriteOneRelationBuilder.Builder<Op, never, WriteOneRelationBuilder.DataFormat[Op["op"]]>;
-    connect(where: Input.UniqueWhere<GraphQlLiteral>): WriteOneRelationBuilder.Builder<Op, never, WriteOneRelationBuilder.DataFormat[Op["op"]]>;
-    delete(): WriteOneRelationBuilder.Builder<WriteOperation.Update, never, Input.UpdateOneRelationInput<GraphQlLiteral<string>>>;
-    disconnect(): WriteOneRelationBuilder.Builder<WriteOperation.Update, never, Input.UpdateOneRelationInput<GraphQlLiteral<string>>>;
-    update(data: WriteDataBuilder.DataLike<WriteOperation.Update>): WriteOneRelationBuilder<WriteOperation.ContentfulOperation, "create" | "update" | "delete" | "connect" | "disconnect" | "upsert", {
-        update: Input.UpdateDataInput<GraphQlLiteral<string>>;
-    }>;
-    upsert(update: WriteDataBuilder.DataLike<WriteOperation.Update>, create: WriteDataBuilder.DataLike<WriteOperation.Create>): this | WriteOneRelationBuilder.Builder<WriteOperation.Update, never, Input.UpdateOneRelationInput<GraphQlLiteral<string>>>;
-}
-
-declare namespace WriteOneRelationBuilder {
-    interface DataFormat {
-        create: Input.CreateOneRelationInput<GraphQlLiteral>;
-        update: Input.UpdateOneRelationInput<GraphQlLiteral>;
-    }
-    type Builder<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']], D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']]> = Omit<WriteOneRelationBuilder<Op, Allowed, D>, Exclude<WriteRelationOps[WriteOperation.ContentfulOperation['op']], Allowed>>;
-    type BuilderFactory<Op extends WriteOperation.ContentfulOperation, Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']], D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']]> = D | Builder<Op, never, D> | ((builder: Builder<Op, Allowed, D>) => Builder<Op, never, D>);
-}
-
-declare namespace WriteOperation {
-    interface Operation {
-        op: 'create' | 'update' | 'delete';
-    }
-    abstract class Operation implements Operation {
-    }
-    interface ContentfulOperation {
-        op: 'create' | 'update';
-    }
-    abstract class ContentfulOperation extends Operation implements ContentfulOperation {
-    }
-    class Update extends ContentfulOperation {
-        readonly op: "update";
-    }
-    class Create extends ContentfulOperation {
-        readonly op: "create";
-    }
-    class Delete extends Operation {
-        readonly op: "delete";
-    }
-}
-
-declare interface WriteRelationOps {
-    create: 'create' | 'connect';
-    update: 'create' | 'connect' | 'delete' | 'disconnect' | 'update' | 'upsert';
-}
-
-export { }