@takeshape/schema 11.52.0 → 11.55.0

package/dist/template-shapes/__tests__/where.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/template-shapes/__tests__/where.test.js

@@ -0,0 +1,218 @@
+import massiveSchemaJson from '@/examples/latest/massive-schema.json';
+import millSchemaJson from '@/examples/latest/mill-components-schema.json';
+import { DEFAULT_ENTITLEMENTS } from '@takeshape/util';
+import { expect, test } from 'vitest';
+import { createMockSchema } from "../../mocks.js";
+import { isEqualRelationship } from "../../relationships.js";
+import { applyDefaultsToSchema } from "../../schema-util.js";
+import { isModelShape } from "../../types/index.js";
+import { validateSchema } from "../../validate/validate.js";
+import { getWhereShape } from "../where.js";
+const massiveSchema = applyDefaultsToSchema(massiveSchemaJson);
+const millSchema = applyDefaultsToSchema(millSchemaJson);
+async function validateShapes(shapes) {
+    return (await validateSchema({
+        entitlements: DEFAULT_ENTITLEMENTS
+    }, createMockSchema('project-id', { shapes }))).errors;
+}
+test('getWhereShape - massive', async () => {
+    const { shapeName, dependencies } = getWhereShape(massiveSchema, Object.values(massiveSchema.shapes).filter(isModelShape));
+    expect(await validateShapes(dependencies)).toEqual(undefined);
+    expect(shapeName).toBe('TSWhereInput');
+    expect(dependencies).toMatchSnapshot();
+});
+test('getWhereShape - mill', async () => {
+    const { shapeName, dependencies } = getWhereShape(millSchema, Object.values(millSchema.shapes).filter(isModelShape));
+    expect(await validateShapes(dependencies)).toEqual(undefined);
+    expect(shapeName).toBe('TSWhereInput');
+    expect(dependencies).toMatchSnapshot();
+});
+test('getWhereShape - recursive', async () => {
+    const schema = createMockSchema('project-id', {
+        shapes: {
+            Node: {
+                name: 'Node',
+                title: 'Node',
+                id: 'node-id',
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foreign: { '@ref': 'stripe:Customer' },
+                        left: { '@ref': 'local:Node' },
+                        right: { '@ref': 'local:Node' },
+                        value: { type: 'number' }
+                    }
+                }
+            },
+            Stripe_Customer: {
+                name: 'Stripe_Customer',
+                title: 'Stripe_Customer',
+                id: 'Stripe_Customer',
+                schema: {
+                    type: 'object',
+                    properties: {}
+                }
+            }
+        },
+        services: {
+            stripe: {
+                id: 'stripe',
+                title: 'Stripe',
+                namespace: 'Stripe',
+                provider: 'openapi',
+                serviceType: 'openapi',
+                authenticationType: 'none'
+            }
+        }
+    });
+    const { shapeName, dependencies } = getWhereShape(schema, [schema.shapes.Node]);
+    expect(await validateShapes(dependencies)).toEqual(undefined);
+    expect(shapeName).toBe('TSWhereNodeInput');
+    expect(dependencies).toMatchInlineSnapshot(`
+    {
+      "TSWhereNode": {
+        "id": "TSWhereNode",
+        "name": "TSWhereNode",
+        "schema": {
+          "properties": {
+            "left": {
+              "@ref": "local:TSWhereNode",
+            },
+            "right": {
+              "@ref": "local:TSWhereNode",
+            },
+            "value": {
+              "@ref": "local:TSWhereNumber",
+            },
+          },
+          "type": "object",
+        },
+        "title": "TSWhereNode",
+      },
+      "TSWhereNodeInput": {
+        "id": "TSWhereNodeInput",
+        "name": "TSWhereNodeInput",
+        "schema": {
+          "properties": {
+            "AND": {
+              "items": {
+                "@ref": "local:TSWhereNodeInput",
+              },
+              "type": "array",
+            },
+            "NOT": {
+              "@ref": "local:TSWhereNodeInput",
+            },
+            "OR": {
+              "items": {
+                "@ref": "local:TSWhereNodeInput",
+              },
+              "type": "array",
+            },
+            "left": {
+              "@ref": "local:TSWhereNode",
+            },
+            "right": {
+              "@ref": "local:TSWhereNode",
+            },
+            "value": {
+              "@ref": "local:TSWhereNumber",
+            },
+          },
+          "type": "object",
+        },
+        "title": "TSWhereNodeInput",
+      },
+      "TSWhereNumber": {
+        "id": "TSWhereNumber",
+        "name": "TSWhereNumber",
+        "schema": {
+          "properties": {
+            "eq": {
+              "description": "Exact match",
+              "type": "number",
+            },
+            "gt": {
+              "description": "Greater than",
+              "type": "number",
+            },
+            "gte": {
+              "description": "Greater than or equal",
+              "type": "number",
+            },
+            "in": {
+              "description": "Array of possible exact match values.",
+              "items": {
+                "type": "number",
+              },
+              "type": "array",
+            },
+            "lt": {
+              "description": "Less than",
+              "type": "number",
+            },
+            "lte": {
+              "description": "Less than or equal",
+              "type": "number",
+            },
+          },
+          "type": "object",
+        },
+        "title": "TSWhereNumber",
+      },
+    }
+  `);
+});
+test('isEqualRelationship - non-relationship', () => {
+    expect(isEqualRelationship({ type: 'string' }, { type: 'number' })).toBe(true);
+});
+test('isEqualRelationship - relationship to non-relationship', () => {
+    const a = {
+        '@resolver': {
+            name: 'shapedb:getRelated',
+            service: 'shapedb'
+        },
+        oneOf: [{ '@ref': 'local:A' }, { '@ref': 'local:B' }, { '@ref': 'local:C' }]
+    };
+    const b = {
+        type: 'string'
+    };
+    expect(isEqualRelationship(a, b)).toBe(false);
+    expect(isEqualRelationship(b, a)).toBe(false);
+});
+test('isEqualRelationship - relationships', () => {
+    const a = {
+        '@resolver': {
+            name: 'shapedb:getRelated',
+            service: 'shapedb'
+        },
+        oneOf: [{ '@ref': 'local:A' }, { '@ref': 'local:B' }, { '@ref': 'local:C' }]
+    };
+    const b = {
+        '@resolver': {
+            name: 'shapedb:getRelated',
+            service: 'shapedb'
+        },
+        oneOf: [{ '@ref': 'local:C' }, { '@ref': 'local:A' }, { '@ref': 'local:B' }]
+    };
+    expect(isEqualRelationship(a, b)).toBe(true);
+    expect(isEqualRelationship(b, a)).toBe(true);
+});
+test('isEqualRelationship - relationships', () => {
+    const a = {
+        '@resolver': {
+            name: 'shapedb:getRelated',
+            service: 'shapedb'
+        },
+        oneOf: [{ '@ref': 'local:A' }, { '@ref': 'local:B' }, { '@ref': 'local:C' }]
+    };
+    const b = {
+        '@resolver': {
+            name: 'shapedb:getRelated',
+            service: 'shapedb'
+        },
+        oneOf: [{ '@ref': 'local:C' }]
+    };
+    expect(isEqualRelationship(a, b)).toBe(false);
+    expect(isEqualRelationship(b, a)).toBe(false);
+});

package/dist/template-shapes/index.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectSchemaJSON } from '../project-schema/index.ts';
+import type { ResolvedTemplate } from './types.ts';
+export declare function resolveTemplate(projectSchema: ProjectSchemaJSON, templateName: string, shapeName: string): ResolvedTemplate;
+/**
+ * Check if a string is a known template such as `PaginatedList`
+ */
+export declare function isValidTemplate(template: string): boolean;

package/dist/template-shapes/names.d.ts

@@ -0,0 +1,10 @@
+import type { TemplateVerbs } from './types.ts';
+/**
+ * Construct a shape name used for a mutation input shape.
+ */
+export declare function getMutationInputShapeName(verb: TemplateVerbs): (shapeName: string) => string;
+/**
+ * Create a shape name variant for an input.
+ */
+export declare function getInputShapeName(shapeName: string): string;
+export declare function getOutputShapeName(name: string): string;

package/dist/template-shapes/templates.d.ts

@@ -0,0 +1,32 @@
+import type { ObjectSchema, PropertySchema, ShapeJSON } from '../project-schema/index.ts';
+import { TemplateVerbs } from './types.ts';
+import type { ResolvedTemplate, TemplateContext } from './types.ts';
+export declare const TSGetArgs: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSGetSingletonArgs: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSListArgs: (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSSearchArgs: (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const CreateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const UpdateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DuplicateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DeleteArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const PaginatedList: typeof getPaginatedListShape;
+export declare const SearchResults: typeof getSearchResultsShape;
+export declare const CreateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const UpdateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DuplicateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DeleteResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSSearchSortInput: ShapeJSON;
+export declare const commonSearchProps: Record<string, PropertySchema>;
+export declare const localeProps: ObjectSchema;
+export declare const termsProps: ObjectSchema;
+export declare const TSContentStructureInput: ShapeJSON;
+export declare function getPaginatedListShape(context: unknown, shape: ShapeJSON): ResolvedTemplate;
+export declare function getSearchResultsShape(context: unknown, shape: ShapeJSON): ResolvedTemplate;
+export declare function getIDQueryArgs(templateName: string): (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+/**
+ * Construct shapes for a mutation inputs, given source shape info.
+ */
+export declare function getMutationArgs(templateName: string, verb: TemplateVerbs): ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare function getMutationResultType(verb: TemplateVerbs): (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const commonSearchArgs: ObjectSchema;
+export declare function getShapeListQueryArgs(templateName: string, legacyArgs: boolean): (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;

package/dist/template-shapes/templates.js

@@ -0,0 +1,319 @@
+import { deepClone, formatShapeName, isDefined, visit } from '@takeshape/util';
+import get from 'lodash/get.js';
+import keyBy from 'lodash/keyBy.js';
+import { createInputSchema } from "../create-input-schema.js";
+import { listTypePrefix } from "../migration/index.js";
+import { getFlattenedTemplateShapeName, getRef, getRefShapeName, refItemToAtRef, refItemToNamespacedShapeName } from "../refs.js";
+import { createShape, getShapeDependencies } from "../schema-util.js";
+import { isCachedShape } from "../types/index.js";
+import { mergeObjectSchemas, mergeSchemaProperties } from "../util/merge.js";
+import { getInputShapeName, getMutationInputShapeName } from "./names.js";
+import { TemplateVerbs } from "./types.js";
+import { getWhereSearchArg } from "./where.js";
+export const TSGetArgs = getIDQueryArgs('TSGetArgs');
+export const TSGetSingletonArgs = getIDQueryArgs('TSGetSingletonArgs');
+export const TSListArgs = getShapeListQueryArgs('TSListArgs', true);
+export const TSSearchArgs = getShapeListQueryArgs('TSSearchArgs', false);
+export const CreateArgs = getMutationArgs('CreateArgs', TemplateVerbs.Create);
+export const UpdateArgs = getMutationArgs('UpdateArgs', TemplateVerbs.Update);
+export const DuplicateArgs = getMutationArgs('DuplicateArgs', TemplateVerbs.Duplicate);
+export const DeleteArgs = getMutationArgs('DeleteArgs', TemplateVerbs.Delete);
+export const PaginatedList = getPaginatedListShape;
+export const SearchResults = getSearchResultsShape;
+export const CreateResult = getMutationResultType(TemplateVerbs.Create);
+export const UpdateResult = getMutationResultType(TemplateVerbs.Update);
+export const DuplicateResult = getMutationResultType(TemplateVerbs.Duplicate);
+export const DeleteResult = getMutationResultType(TemplateVerbs.Delete);
+export const TSSearchSortInput = createShape('TSSearchSortInput', {
+    type: 'object',
+    properties: {
+        field: { type: 'string' },
+        order: {
+            type: 'string',
+            description: '"asc" for ascending or "desc" for descending'
+        }
+    },
+    required: ['field', 'order']
+});
+export const commonSearchProps = {
+    terms: { type: 'string' },
+    from: {
+        type: 'integer',
+        description: 'The offset from the first result you want to fetch.'
+    },
+    size: {
+        type: 'integer',
+        description: 'The maximum number of items to return.'
+    },
+    filter: {
+        type: 'object',
+        description: 'An elasticsearch style filter. Overrides onlyEnabled.'
+    },
+    sort: {
+        type: 'array',
+        description: 'An list of fields to sort by.',
+        items: {
+            '@ref': `local:${TSSearchSortInput.name}`
+        }
+    }
+};
+export const localeProps = {
+    type: 'object',
+    properties: {
+        locale: { type: 'string' },
+        enableLocaleFallback: { type: 'boolean', default: true }
+    }
+};
+export const termsProps = {
+    type: 'object',
+    properties: {
+        terms: { type: 'string' }
+    }
+};
+export const TSContentStructureInput = createShape('TSContentStructureInput', {
+    type: 'object',
+    properties: {
+        path: {
+            type: 'string',
+            description: 'A deep path to the array being updated (e.g. a.b[1].c).'
+        },
+        structure: {
+            type: 'array',
+            description: 'An array where the indices represent the to index, and the values represent the from index.' +
+                'For example to transform ["a","b","c","d"] into ["c","a"], this value would be [2,0].',
+            items: {
+                type: 'integer'
+            }
+        }
+    },
+    required: ['path']
+}, { description: 'Describes a structural update to an array of data.' });
+export function getPaginatedListShape(context, shape) {
+    const shapeName = `${shape.name}${listTypePrefix}`;
+    return {
+        shapeName,
+        dependencies: {
+            [shapeName]: createShape(shapeName, {
+                type: 'object',
+                properties: {
+                    items: { type: 'array', items: { '@ref': `local:${shape.name}` } },
+                    total: { type: 'integer' }
+                },
+                required: ['items', 'total']
+            })
+        }
+    };
+}
+export function getSearchResultsShape(context, shape) {
+    const shapeName = `${shape.name}SearchResults`;
+    return {
+        shapeName,
+        dependencies: {
+            [shapeName]: createShape(shapeName, {
+                type: 'object',
+                properties: {
+                    results: {
+                        type: 'array',
+                        items: { '@ref': `local:${shape.name}` }
+                    },
+                    total: { type: 'integer' }
+                },
+                required: ['results', 'total']
+            }, { description: `${shape.name} search results` })
+        }
+    };
+}
+const contentStructureFields = {
+    type: 'object',
+    properties: {
+        structure: {
+            type: 'array',
+            items: {
+                '@ref': 'local:TSContentStructureInput'
+            }
+        }
+    }
+};
+const idSchema = {
+    type: 'object',
+    properties: {
+        _id: { type: 'string' }
+    },
+    required: ['_id']
+};
+export function getIDQueryArgs(templateName) {
+    return (context, shape) => {
+        const schema = shape.model?.type !== 'single' ? mergeSchemaProperties(idSchema, localeProps) : localeProps;
+        const shapeName = getFlattenedTemplateShapeName(shape.name, templateName);
+        return {
+            shapeName,
+            dependencies: {
+                [shapeName]: createShape(shapeName, schema)
+            }
+        };
+    };
+}
+function rewriteRefs(context, shapeSchema, rewriteShapeName) {
+    const newSchema = deepClone(shapeSchema);
+    visit(newSchema, ['$ref', '@ref'], (_, path) => {
+        const parentPath = path.slice(0, -1);
+        const value = get(newSchema, parentPath);
+        if ((value['@ref'] || value.$ref) && !parentPath.includes('@input') && !parentPath.includes('@output')) {
+            const refItem = getRef(context, value);
+            if (refItem) {
+                value['@ref'] = refItem.isForeign
+                    ? refItemToAtRef(refItem)
+                    : `local:${rewriteShapeName(refItemToNamespacedShapeName(refItem))}`;
+                if (value.$ref) {
+                    // biome-ignore lint/performance/noDelete: Property presence may matter here
+                    delete value.$ref;
+                }
+            }
+        }
+    });
+    return newSchema;
+}
+/**
+ * Construct shapes for a mutation inputs, given source shape info.
+ */
+export function getMutationArgs(templateName, verb) {
+    const getShapeName = getMutationInputShapeName(verb);
+    const addLocale = verb === TemplateVerbs.Update || verb === TemplateVerbs.Duplicate;
+    const addStructure = verb === TemplateVerbs.Update;
+    const isUpdate = verb === TemplateVerbs.Update || verb === TemplateVerbs.Duplicate;
+    return ({ projectSchema }, shape) => {
+        const inputName = getShapeName(shape.name);
+        const isSingleton = shape.model && shape.model.type === 'single';
+        const shouldRequireId = !isSingleton &&
+            (verb === TemplateVerbs.Update || verb === TemplateVerbs.Delete || verb === TemplateVerbs.Duplicate);
+        let rewrittenSchema;
+        let inputShapeSchema;
+        if (verb !== TemplateVerbs.Delete) {
+            rewrittenSchema = createInputSchema(shape.schema, { isUpdate });
+            inputShapeSchema = rewriteRefs(projectSchema, rewrittenSchema, getInputShapeName);
+        }
+        const inputShape = createShape(inputName, mergeObjectSchemas(shouldRequireId ? idSchema : undefined, inputShapeSchema), { description: `${verb} ${shape.name} input` });
+        const argsShapeName = getFlattenedTemplateShapeName(shape.name, templateName);
+        const argsShape = createShape(argsShapeName, mergeObjectSchemas({
+            type: 'object',
+            properties: {
+                input: { '@ref': `local:${inputShape.name}` },
+                clientMutationId: { type: 'string' }
+            },
+            required: ['input']
+        }, addStructure ? contentStructureFields : undefined, addLocale ? localeProps : undefined));
+        return {
+            shapeName: argsShapeName,
+            dependencies: {
+                [inputName]: inputShape,
+                [argsShapeName]: argsShape,
+                ...(verb !== TemplateVerbs.Delete &&
+                    keyBy(getShapeDependencies(projectSchema, 
+                    // get the shape dependencies of the shape with the @input swapped
+                    createShape(inputShape.name, rewrittenSchema), (propSchema) => {
+                        if (propSchema['@resolver']) {
+                            return false;
+                        }
+                        const shapeName = getRefShapeName(projectSchema, propSchema);
+                        if (shapeName) {
+                            return shapeName !== 'TSRelationship' && !projectSchema.shapes[getInputShapeName(shapeName)];
+                        }
+                        return true;
+                    })
+                        .map((shapeName) => {
+                        const shape = projectSchema.shapes[shapeName];
+                        if (!shape) {
+                            return;
+                        }
+                        // We only allow partial input at the top-level
+                        return createShape(getInputShapeName(shapeName), rewriteRefs(projectSchema, createInputSchema(shape.schema), getInputShapeName));
+                    })
+                        .filter(isDefined), 'name')),
+                ...(addStructure ? { TSContentStructureInput } : {})
+            }
+        };
+    };
+}
+export function getMutationResultType(verb) {
+    return (context, shape) => {
+        const shapeName = formatShapeName([verb, shape.name, 'result'], {
+            shapeNameIndex: 1
+        });
+        const result = verb === TemplateVerbs.Delete ? { type: 'boolean' } : { '@ref': `local:${shape.name}` };
+        return {
+            shapeName,
+            dependencies: {
+                [shapeName]: createShape(shapeName, {
+                    type: 'object',
+                    properties: {
+                        clientMutationId: { type: 'string' },
+                        result
+                    }
+                })
+            }
+        };
+    };
+}
+export const commonSearchArgs = {
+    type: 'object',
+    properties: {
+        terms: { type: 'string' },
+        from: {
+            type: 'integer',
+            description: 'The offset from the first result you want to fetch.'
+        },
+        size: {
+            type: 'integer',
+            description: 'The maximum number of items to return.'
+        },
+        filter: {
+            type: 'object',
+            description: 'An elasticsearch style filter. Overrides onlyEnabled.'
+        },
+        sort: {
+            type: 'array',
+            description: 'An list of fields to sort by.',
+            items: {
+                '@ref': `local:${TSSearchSortInput.name}`
+            }
+        }
+    }
+};
+const legacyListArgs = {
+    type: 'object',
+    properties: {
+        onlyEnabled: {
+            type: 'boolean',
+            default: true,
+            description: 'Filter out content that is not enabled. Defaults to true.'
+        }
+    }
+};
+const shapeFilterProps = {
+    type: 'object',
+    properties: {
+        shapeNames: { type: 'array', items: { type: 'string' } },
+        shapeIds: { type: 'array', items: { type: 'string' } },
+        contentTypeNames: { type: 'array', items: { type: 'string' } },
+        contentTypeIds: { type: 'array', items: { type: 'string' } }
+    }
+};
+export function getShapeListQueryArgs(templateName, legacyArgs) {
+    return (context, shape) => {
+        const { projectSchema } = context;
+        const isAllShapes = shape.name === 'TSSearchable';
+        const shapeName = isAllShapes ? templateName : getFlattenedTemplateShapeName(shape.name, templateName);
+        const shapes = isAllShapes
+            ? Object.values(projectSchema.shapes).filter((s) => s.model !== undefined || isCachedShape(s))
+            : [shape];
+        const { schema, dependencies } = getWhereSearchArg(projectSchema, shapes);
+        return {
+            shapeName,
+            dependencies: {
+                ...dependencies,
+                TSSearchSortInput,
+                [shapeName]: createShape(shapeName, mergeObjectSchemas(commonSearchArgs, localeProps, legacyArgs ? legacyListArgs : undefined, isAllShapes ? shapeFilterProps : undefined, schema))
+            }
+        };
+    };
+}

package/dist/template-shapes/types.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectSchemaJSON, ShapeJSON, ShapeMap } from '../project-schema/index.ts';
+export type ResolvedTemplate = {
+    shapeName: string;
+    dependencies: ShapeMap;
+};
+export type TemplateContext = {
+    projectSchema: ProjectSchemaJSON;
+};
+export type TemplateShapeFactory = (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare enum TemplateVerbs {
+    Create = "create",
+    Update = "update",
+    Duplicate = "duplicate",
+    Delete = "delete"
+}

package/dist/template-shapes/where.d.ts

@@ -0,0 +1,37 @@
+import type { Maybe } from '@takeshape/util';
+import type { ObjectSchema, ProjectSchemaJSON, PropertySchema, ShapeJSON, ShapeMap } from '../project-schema/index.ts';
+import type { ResolvedTemplate } from './types.ts';
+export declare const MAX_RELATIONSHIP_DEPTH = 1;
+export declare const exceededRelationshipDepth: (depth?: number) => boolean;
+type ComparisonOperatorKey = 'eq' | 'lt' | 'lte' | 'gt' | 'gte' | 'in' | 'match' | 'regexp';
+type ShapeThunk = ShapeJSON | (() => ShapeJSON);
+declare class ShapeCache {
+    thunks: Map<string, ShapeThunk>;
+    unresolved: Set<string>;
+    has(shapeName: string): boolean;
+    set(shapeName: string, thunk: ShapeThunk): void;
+    resolveAll(): ShapeMap;
+}
+export declare const fieldTypeComparison: Record<string, {
+    comparators: ComparisonOperatorKey[];
+    type: 'string' | 'number' | 'integer' | 'boolean';
+}>;
+export declare const comparatorDescriptions: Record<string, string>;
+export declare const booleanOperators: string[];
+export declare const boolOpDescriptionMap: Record<string, string>;
+export declare function getFieldTypeComparison(fieldType: string): Maybe<Record<string, PropertySchema>>;
+export type PropertyContext = {
+    shapeCache: ShapeCache;
+    conflictingProperties?: Set<string>;
+    projectSchema: ProjectSchemaJSON;
+    relationshipDepth: number;
+    booleanOperators?: boolean;
+};
+export declare function getFields(typeName: string, shapes: ShapeJSON[], context: PropertyContext): Record<string, PropertySchema>;
+export declare function getPropertyComparisonType(name: string, prop: PropertySchema, shapeName: string, context: PropertyContext): Maybe<Record<string, PropertySchema>>;
+export declare function getWhereShape(projectSchema: ProjectSchemaJSON, selectedShapes: ShapeJSON[]): ResolvedTemplate;
+export declare function getWhereSearchArg(projectSchema: ProjectSchemaJSON, selectedShapes: ShapeJSON[]): {
+    schema: ObjectSchema;
+    dependencies: ShapeMap;
+};
+export {};