@chassdev/client-sdk 2.46.0

package/dist/chunk-Dqa2HsxW.mjs

@@ -0,0 +1,20 @@
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), s = (e, n) => {
+	let r = {};
+	for (var i in e) t(r, i, {
+		get: e[i],
+		enumerable: !0
+	});
+	return n || t(r, Symbol.toStringTag, { value: "Module" }), r;
+}, c = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, l = (n, r, a) => (a = n == null ? {} : e(i(n)), c(r || !n || !n.__esModule ? t(a, "default", {
+	value: n,
+	enumerable: !0
+}) : a, n));
+//#endregion
+export { s as n, l as r, o as t };

package/dist/chunk-mLOUI7ql.js

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),s=(e,n)=>{let r={};for(var i in e)t(r,i,{get:e[i],enumerable:!0});return n||t(r,Symbol.toStringTag,{value:`Module`}),r},c=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},l=(n,r,a)=>(a=n==null?{}:e(i(n)),c(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return s}}),Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return l}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return o}});

package/dist/core/generated/index.d.ts

@@ -0,0 +1,7 @@
+import { type TwentyClientOptions } from '../../shared/twenty-client-options.type';
+export declare class CoreApiClient {
+    query: any;
+    mutation: any;
+    upload: any;
+    constructor(_options?: TwentyClientOptions);
+}

package/dist/core/generated/schema.d.ts

@@ -0,0 +1 @@
+export type CoreSchema = {};

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export { CoreApiClient } from './generated/index';
+export * as CoreSchema from './generated/schema';

package/dist/core.cjs

@@ -0,0 +1 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("./chunk-mLOUI7ql.js");var t=class{constructor(e){throw Error("CoreApiClient was not generated. Install this app on a Chass instance or run `yarn chass dev`.")}},n=e.n({});exports.CoreApiClient=t,Object.defineProperty(exports,"CoreSchema",{enumerable:!0,get:function(){return n}});

package/dist/core.mjs

@@ -0,0 +1,9 @@
+import { n as e } from "./chunk-Dqa2HsxW.mjs";
+//#region src/core/generated/index.ts
+var t = class {
+	constructor(e) {
+		throw Error("CoreApiClient was not generated. Install this app on a Chass instance or run `yarn chass dev`.");
+	}
+}, n = /* @__PURE__ */ e({});
+//#endregion
+export { t as CoreApiClient, n as CoreSchema };

package/dist/generate/client-wrapper.d.ts

@@ -0,0 +1,7 @@
+type ClientWrapperOptions = {
+    apiClientName: string;
+    defaultUrl: string;
+    includeUploadFile: boolean;
+};
+export declare const buildClientWrapperSource: (templateSource: string, options: ClientWrapperOptions) => string;
+export {};

package/dist/generate/fs-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const ensureDir: (dirPath: string) => Promise<string | undefined>;
+export declare const emptyDir: (dirPath: string) => Promise<void>;
+export declare const move: (src: string, dest: string) => Promise<void>;
+export declare const remove: (filePath: string) => Promise<void>;

package/dist/generate/generate-core-client.d.ts

@@ -0,0 +1,10 @@
+export declare const GENERATED_CORE_DIR = "core/generated";
+export declare const generateCoreClientFromSchema: ({ schema, outputPath, clientWrapperTemplateSource, }: {
+    schema: string;
+    outputPath: string;
+    clientWrapperTemplateSource?: string | undefined;
+}) => Promise<void>;
+export declare const replaceCoreClient: ({ packageRoot, schema, }: {
+    packageRoot: string;
+    schema: string;
+}) => Promise<void>;

package/dist/generate/generate-metadata-client.d.ts

@@ -0,0 +1,5 @@
+export declare const generateMetadataClient: ({ schema, outputPath, clientWrapperTemplateSource, }: {
+    schema: string;
+    outputPath: string;
+    clientWrapperTemplateSource?: string | undefined;
+}) => Promise<void>;

package/dist/generate/genql/config.d.ts

@@ -0,0 +1,9 @@
+export declare const RUNTIME_LIB_NAME = "./runtime";
+export interface Config {
+    schema?: string;
+    output?: string;
+    scalarTypes?: {
+        [k: string]: string;
+    };
+    sortProperties?: boolean;
+}

package/dist/generate/genql/helpers/files.d.ts

@@ -0,0 +1,2 @@
+export declare const ensurePath: (path: string[], clear?: boolean) => Promise<void>;
+export declare const writeFileToPath: (path: string[], content: string) => Promise<void>;

package/dist/generate/genql/helpers/prettify.d.ts

@@ -0,0 +1,2 @@
+import { BuiltInParserName } from 'prettier';
+export declare const prettify: (code: string, parser?: BuiltInParserName | undefined) => Promise<string>;

package/dist/generate/genql/index.d.ts

@@ -0,0 +1,2 @@
+export { generate } from './main';
+export { type Config } from './config';

package/dist/generate/genql/main.d.ts

@@ -0,0 +1,2 @@
+import { type Config } from './config';
+export declare const generate: (config: Config) => Promise<void>;

package/dist/generate/genql/render/client/renderClient.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const renderClientEsm: (schema: GraphQLSchema, ctx: RenderContext) => void;

package/dist/generate/genql/render/common/RenderContext.d.ts

@@ -0,0 +1,24 @@
+import { GraphQLSchema } from 'graphql';
+import { BuiltInParserName } from 'prettier';
+import { Config } from '../../config';
+interface Import {
+    isDefault: boolean;
+    module?: string;
+    alias?: string;
+}
+interface ImportMap {
+    [from: string]: Import[];
+}
+export declare class RenderContext {
+    schema?: GraphQLSchema | undefined;
+    config?: Config | undefined;
+    protected codeBlocks: string[];
+    protected imports: ImportMap;
+    protected importAliasCounter: number;
+    constructor(schema?: GraphQLSchema | undefined, config?: Config | undefined);
+    addCodeBlock(block: string): void;
+    addImport(from: string, isDefault: boolean, module?: string, fromAbsolute?: boolean, noAlias?: boolean): string | undefined;
+    protected getImportBlock(): string | undefined;
+    toCode(parser?: BuiltInParserName, pretty?: boolean): Promise<string>;
+}
+export {};

package/dist/generate/genql/render/common/comment.d.ts

@@ -0,0 +1,8 @@
+import { GraphQLArgument, GraphQLEnumValue, GraphQLField, GraphQLInputField, GraphQLNamedType } from 'graphql';
+export declare const comment: (comment: {
+    text?: string | null | undefined;
+    deprecated?: string | null | undefined;
+}) => string;
+export declare const typeComment: (type: GraphQLNamedType) => string;
+export declare const fieldComment: (field: GraphQLEnumValue | GraphQLField<any, any, any>) => string;
+export declare const argumentComment: (arg: GraphQLArgument | GraphQLInputField) => string;

package/dist/generate/genql/render/common/excludedTypes.d.ts

@@ -0,0 +1 @@
+export declare const excludedTypes: string[];

package/dist/generate/genql/render/common/relativeImportPath.d.ts

@@ -0,0 +1 @@
+export declare const relativeImportPath: (from: string, to: string) => string;

package/dist/generate/genql/render/common/renderTyping.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLInputType, GraphQLNonNull, GraphQLOutputType } from 'graphql';
+export declare const renderTyping: (type: import("graphql").GraphQLEnumType | import("graphql").GraphQLInputObjectType | import("graphql").GraphQLInterfaceType | import("graphql").GraphQLList<GraphQLInputType> | import("graphql").GraphQLList<GraphQLOutputType> | GraphQLNonNull<import("graphql").GraphQLEnumType | import("graphql").GraphQLInputObjectType | import("graphql").GraphQLList<GraphQLInputType> | import("graphql").GraphQLScalarType<unknown, unknown>> | GraphQLNonNull<import("graphql").GraphQLEnumType | import("graphql").GraphQLInterfaceType | import("graphql").GraphQLList<GraphQLOutputType> | import("graphql").GraphQLObjectType<any, any> | import("graphql").GraphQLScalarType<unknown, unknown> | import("graphql").GraphQLUnionType> | import("graphql").GraphQLObjectType<any, any> | import("graphql").GraphQLScalarType<unknown, unknown> | import("graphql").GraphQLScalarType<unknown, unknown> | import("graphql").GraphQLUnionType, undefinableValues: boolean, undefinableFields: boolean, root?: boolean, wrap?: any) => string;

package/dist/generate/genql/render/common/support.d.ts

@@ -0,0 +1,2 @@
+export declare function sortKeys(obj: Record<any, any>): Record<any, any>;
+export declare function intersection<T>(a: T[][]): T[];

package/dist/generate/genql/render/requestTypes/inputObjectType.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLInputObjectType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const inputObjectType: (type: GraphQLInputObjectType, ctx: RenderContext) => void;

package/dist/generate/genql/render/requestTypes/objectType.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const objectType: (type: GraphQLInterfaceType | GraphQLObjectType<any, any>, ctx: RenderContext) => void;
+export declare const toArgsString: (field: GraphQLField<any, any, any>) => string;

package/dist/generate/genql/render/requestTypes/renderRequestTypes.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const renderRequestTypes: (schema: GraphQLSchema, ctx: RenderContext) => void;

package/dist/generate/genql/render/requestTypes/requestTypeName.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLNamedType } from 'graphql';
+export declare const requestTypeName: (type?: GraphQLNamedType | undefined) => string;

package/dist/generate/genql/render/requestTypes/unionType.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLUnionType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const unionType: (type: GraphQLUnionType, ctx: RenderContext) => void;

package/dist/generate/genql/render/responseTypes/enumType.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLEnumType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const enumType: (type: GraphQLEnumType, ctx: RenderContext) => void;

package/dist/generate/genql/render/responseTypes/interfaceType.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLInterfaceType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const interfaceType: (type: GraphQLInterfaceType, ctx: RenderContext) => void;

package/dist/generate/genql/render/responseTypes/objectType.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const objectType: (type: GraphQLInterfaceType | GraphQLObjectType<any, any>, ctx: RenderContext) => void;

package/dist/generate/genql/render/responseTypes/renderResponseTypes.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const renderResponseTypes: (schema: GraphQLSchema, ctx: RenderContext) => void;

package/dist/generate/genql/render/responseTypes/scalarType.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLScalarType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare function renderScalarTypes(ctx: RenderContext, types: GraphQLScalarType[]): string;

package/dist/generate/genql/render/responseTypes/typeMappedAlias.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLNamedType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const getTypeMappedAlias: (type: GraphQLNamedType, ctx: RenderContext) => string;

package/dist/generate/genql/render/responseTypes/unionType.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLUnionType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const unionType: (type: GraphQLUnionType, ctx: RenderContext) => void;

package/dist/generate/genql/render/schema/renderSchema.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const renderSchema: (schema: GraphQLSchema, ctx: RenderContext) => void;

package/dist/generate/genql/render/typeGuards/renderTypeGuards.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const renderTypeGuards: (schema: GraphQLSchema, ctx: RenderContext) => void;

package/dist/generate/genql/render/typeMap/objectType.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLInterfaceType, GraphQLObjectType, GraphQLInputObjectType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+import { FieldMap } from '../../runtime/types';
+export declare const objectType: (type: GraphQLInputObjectType | GraphQLInterfaceType | GraphQLObjectType<any, any>, ctx: RenderContext) => FieldMap<string>;

package/dist/generate/genql/render/typeMap/renderTypeMap.d.ts

@@ -0,0 +1,5 @@
+import { CompressedTypeMap, TypeMap } from '../../runtime/types';
+import { GraphQLSchema } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+export declare const renderTypeMap: (schema: GraphQLSchema, ctx: RenderContext) => void;
+export declare function replaceTypeNamesWithIndexes(typeMap: TypeMap<string>): CompressedTypeMap<number>;

package/dist/generate/genql/render/typeMap/scalarType.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLEnumType, GraphQLScalarType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+import { Type } from '../../runtime/types';
+export declare const scalarType: (type: GraphQLEnumType | GraphQLScalarType<unknown, unknown>, _: RenderContext) => Type<string>;

package/dist/generate/genql/render/typeMap/support.d.ts

@@ -0,0 +1 @@
+export declare function isEmpty(x: any): boolean;

package/dist/generate/genql/render/typeMap/unionType.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLUnionType } from 'graphql';
+import { RenderContext } from '../common/RenderContext';
+import { FieldMap } from '../../runtime/types';
+export declare const unionType: (type: GraphQLUnionType, _: RenderContext) => FieldMap<string>;

package/dist/generate/genql/runtime/batcher.d.ts

@@ -0,0 +1,105 @@
+import type { GraphqlOperation } from './generateGraphqlOperation';
+type Variables = Record<string, any>;
+type QueryError = Error & {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: any;
+    rid: string;
+    details?: Record<string, any>;
+};
+type Result = {
+    data: Record<string, any>;
+    errors: Array<QueryError>;
+};
+type Fetcher = (batchedQuery: GraphqlOperation | Array<GraphqlOperation>) => Promise<Array<Result>>;
+type Options = {
+    batchInterval?: number;
+    shouldBatch?: boolean;
+    maxBatchSize?: number;
+};
+type Queue = Array<{
+    request: GraphqlOperation;
+    resolve: (...args: Array<any>) => any;
+    reject: (...args: Array<any>) => any;
+}>;
+/**
+ * Create a batcher client.
+ * @param {Fetcher} fetcher                 - A function that can handle the network requests to graphql endpoint
+ * @param {Options} options                 - the options to be used by client
+ * @param {boolean} options.shouldBatch     - should the client batch requests. (default true)
+ * @param {integer} options.batchInterval   - duration (in MS) of each batch window. (default 6)
+ * @param {integer} options.maxBatchSize    - max number of requests in a batch. (default 0)
+ * @param {boolean} options.defaultHeaders  - default headers to include with every request
+ *
+ * @example
+ * const fetcher = batchedQuery => fetch('path/to/graphql', {
+ *    method: 'post',
+ *    headers: {
+ *      Accept: 'application/json',
+ *      'Content-Type': 'application/json',
+ *    },
+ *    body: JSON.stringify(batchedQuery),
+ *    credentials: 'include',
+ * })
+ * .then(response => response.json())
+ *
+ * const client = new QueryBatcher(fetcher, { maxBatchSize: 10 })
+ */
+export declare class QueryBatcher {
+    fetcher: Fetcher;
+    _options: Options;
+    _queue: Queue;
+    constructor(fetcher: Fetcher, { batchInterval, shouldBatch, maxBatchSize }?: Options);
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {promise} resolves to parsed json of server response
+     *
+     * @example
+     * client.fetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    fetch(query: string, variables?: Variables, operationName?: string, overrides?: Options): Promise<Result>;
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {Promise<Array<Result>>} resolves to parsed json of server response
+     *
+     * @example
+     * client.forceFetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    forceFetch(query: string, variables?: Variables, operationName?: string, overrides?: Options): Promise<Result>;
+}
+export {};

package/dist/generate/genql/runtime/createClient.d.ts

@@ -0,0 +1,23 @@
+import { type BatchOptions } from './fetcher';
+import type { ExecutionResult, LinkedType } from './types';
+import { type GraphqlOperation } from './generateGraphqlOperation';
+export type Headers = HeadersInit | (() => HeadersInit) | (() => Promise<HeadersInit>);
+export type BaseFetcher = (operation: GraphqlOperation | GraphqlOperation[]) => Promise<ExecutionResult | ExecutionResult[]>;
+export type ClientOptions = Omit<RequestInit, 'body' | 'headers'> & {
+    url?: string;
+    batch?: BatchOptions | boolean;
+    fetcher?: BaseFetcher;
+    fetch?: Function;
+    headers?: Headers;
+};
+export declare const createClient: ({ queryRoot, mutationRoot, subscriptionRoot, ...options }: Omit<RequestInit, "body" | "headers"> & {
+    url?: string | undefined;
+    batch?: boolean | BatchOptions | undefined;
+    fetcher?: BaseFetcher | undefined;
+    fetch?: Function | undefined;
+    headers?: Headers | undefined;
+} & {
+    queryRoot?: LinkedType | undefined;
+    mutationRoot?: LinkedType | undefined;
+    subscriptionRoot?: LinkedType | undefined;
+}) => any;

package/dist/generate/genql/runtime/error.d.ts

@@ -0,0 +1,18 @@
+export declare class GenqlError extends Error {
+    errors: Array<GraphqlError>;
+    /**
+     * Partial data returned by the server
+     */
+    data?: any;
+    constructor(errors: any[], data: any);
+}
+interface GraphqlError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: string[];
+    extensions?: Record<string, any>;
+}
+export {};

package/dist/generate/genql/runtime/fetcher.d.ts

@@ -0,0 +1,10 @@
+import type { ClientOptions } from './createClient';
+import type { GraphqlOperation } from './generateGraphqlOperation';
+export interface Fetcher {
+    (gql: GraphqlOperation): Promise<any>;
+}
+export type BatchOptions = {
+    batchInterval?: number;
+    maxBatchSize?: number;
+};
+export declare const createFetcher: ({ url, headers, fetcher, fetch: _fetch, batch, ...rest }: ClientOptions) => Fetcher;

package/dist/generate/genql/runtime/generateGraphqlOperation.d.ts

@@ -0,0 +1,30 @@
+import type { LinkedField, LinkedType } from './types';
+export interface Args {
+    [arg: string]: any | undefined;
+}
+export interface Fields {
+    [field: string]: Request;
+}
+export type Request = boolean | number | Fields;
+export interface Variables {
+    [name: string]: {
+        value: any;
+        typing: [LinkedType, string];
+    };
+}
+export interface Context {
+    root: LinkedType;
+    varCounter: number;
+    variables: Variables;
+    fragmentCounter: number;
+    fragments: string[];
+}
+export interface GraphqlOperation {
+    query: string;
+    variables?: {
+        [name: string]: any;
+    };
+    operationName?: string;
+}
+export declare const generateGraphqlOperation: (operation: "mutation" | "query" | "subscription", root: LinkedType, fields?: Fields | undefined) => GraphqlOperation;
+export declare const getFieldFromPath: (root: LinkedType | undefined, path: string[]) => LinkedField;

package/dist/generate/genql/runtime/index.d.ts

@@ -0,0 +1,11 @@
+export { createClient } from './createClient';
+export type { ClientOptions } from './createClient';
+export type { FieldsSelection } from './typeSelection';
+export { generateGraphqlOperation } from './generateGraphqlOperation';
+export type { GraphqlOperation } from './generateGraphqlOperation';
+export { linkTypeMap } from './linkTypeMap';
+export { createFetcher } from './fetcher';
+export { GenqlError } from './error';
+export declare const everything: {
+    __scalar: boolean;
+};

package/dist/generate/genql/runtime/linkTypeMap.d.ts

@@ -0,0 +1,9 @@
+import type { CompressedTypeMap, LinkedArgMap, LinkedTypeMap } from './types';
+export interface PartialLinkedFieldMap {
+    [field: string]: {
+        type: string;
+        args?: LinkedArgMap;
+    };
+}
+export declare const linkTypeMap: (typeMap: CompressedTypeMap<number>) => LinkedTypeMap;
+export declare const resolveConcreteTypes: (linkedTypeMap: LinkedTypeMap) => LinkedTypeMap;

package/dist/generate/genql/runtime/typeSelection.d.ts

@@ -0,0 +1,28 @@
+export type FieldsSelection<SRC extends Anify<DST> | undefined, DST> = {
+    scalar: SRC;
+    union: Handle__isUnion<SRC, DST>;
+    object: HandleObject<SRC, DST>;
+    array: SRC extends Nil ? never : SRC extends (infer T)[] ? Array<FieldsSelection<T, DST>> : never;
+    __scalar: Handle__scalar<SRC, DST>;
+    never: never;
+}[DST extends Nil ? 'never' : SRC extends Nil ? 'never' : DST extends false | 0 ? 'never' : SRC extends Scalar ? 'scalar' : SRC extends any[] ? 'array' : SRC extends {
+    __isUnion?: any;
+} ? 'union' : DST extends {
+    __scalar?: any;
+} ? '__scalar' : DST extends {} ? 'object' : 'never'];
+type HandleObject<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Pick<{
+    [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<NonNullable<SRC[Key]>, NonNullable<DST[Key]>> : SRC[Key];
+}, Exclude<keyof DST, FieldsToRemove>>;
+type Handle__scalar<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Pick<{
+    [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<SRC[Key], DST[Key]> : SRC[Key];
+}, {
+    [Key in keyof SRC]: SRC[Key] extends Nil ? never : Key extends FieldsToRemove ? never : SRC[Key] extends Scalar ? Key : Key extends keyof DST ? Key : never;
+}[keyof SRC]>;
+type Handle__isUnion<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Omit<SRC, FieldsToRemove>;
+type Scalar = string | number | Date | boolean | null | undefined;
+type Anify<T> = {
+    [P in keyof T]?: any;
+};
+type FieldsToRemove = '__isUnion' | '__scalar' | '__name' | '__args';
+type Nil = undefined | null;
+export {};

package/dist/generate/genql/runtime/types.d.ts

@@ -0,0 +1,55 @@
+export interface ExecutionResult<TData = {
+    [key: string]: any;
+}> {
+    errors?: Array<Error>;
+    data?: TData | null;
+}
+export interface ArgMap<keyType = number> {
+    [arg: string]: [keyType, string] | [keyType] | undefined;
+}
+export type CompressedField<keyType = number> = [
+    type: keyType,
+    args?: ArgMap<keyType>
+];
+export interface CompressedFieldMap<keyType = number> {
+    [field: string]: CompressedField<keyType> | undefined;
+}
+export type CompressedType<keyType = number> = CompressedFieldMap<keyType>;
+export interface CompressedTypeMap<keyType = number> {
+    scalars: Array<keyType>;
+    types: {
+        [type: string]: CompressedType<keyType> | undefined;
+    };
+}
+export type Field<keyType = number> = {
+    type: keyType;
+    args?: ArgMap<keyType>;
+};
+export interface FieldMap<keyType = number> {
+    [field: string]: Field<keyType> | undefined;
+}
+export type Type<keyType = number> = FieldMap<keyType>;
+export interface TypeMap<keyType = number> {
+    scalars: Array<keyType>;
+    types: {
+        [type: string]: Type<keyType> | undefined;
+    };
+}
+export interface LinkedArgMap {
+    [arg: string]: [LinkedType, string] | undefined;
+}
+export interface LinkedField {
+    type: LinkedType;
+    args?: LinkedArgMap;
+}
+export interface LinkedFieldMap {
+    [field: string]: LinkedField | undefined;
+}
+export interface LinkedType {
+    name: string;
+    fields?: LinkedFieldMap;
+    scalar?: string[];
+}
+export interface LinkedTypeMap {
+    [type: string]: LinkedType | undefined;
+}

package/dist/generate/genql/tasks/clientTasks.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { type Config } from '../config';
+export declare const writeClientFiles: (config: Config, schema: GraphQLSchema) => Promise<void>;

package/dist/generate/genql/tasks/schemaTask.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchema } from 'graphql';
+import { type Config } from '../config';
+export declare const loadConfiguredSchema: (config: Config) => Promise<GraphQLSchema>;

package/dist/generate/index.d.ts

@@ -0,0 +1,2 @@
+export { GENERATED_CORE_DIR, generateCoreClientFromSchema, replaceCoreClient, } from './generate-core-client';
+export { generateMetadataClient } from './generate-metadata-client';

package/dist/generate/runtime-templates.d.ts

@@ -0,0 +1,4 @@
+export declare const RUNTIME_TEMPLATE_FILES: {
+    name: string;
+    content: string;
+}[];