@tinacms/graphql 0.0.0-2022230155428 → 0.0.0-2022230211331

package/CHANGELOG.md

@@ -1,9 +1,10 @@
 # tina-graphql
 
-## 0.0.0-2022230155428
+## 0.0.0-2022230211331
 
 ### Patch Changes
 
+- 82174ff50: Modify Database.indexContentByPaths to not require collection parameter
 - a87e1e6fa: Enable query filtering, pagination, sorting
 - abf25c673: The schema can now to used on the frontend (optional for now but will be the main path moving forward).
 
@@ -39,7 +40,7 @@
 - e8b0de1f7: Add `parentTypename` to fields to allow us to disambiguate between fields which have the same field names but different types. Example, an event from field name of `blocks.0.title` could belong to a `Cta` block or a `Hero` block, both of which have a `title` field.
 - Updated dependencies [a87e1e6fa]
 - Updated dependencies [b01f2e382]
-  - @tinacms/datalayer@0.0.0-2022230155428
+  - @tinacms/datalayer@0.0.0-2022230211331
 
 ## 0.59.8
 

package/dist/ast-builder/index.d.ts

@@ -0,0 +1,159 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { FieldDefinitionNode, ScalarTypeDefinitionNode, InputValueDefinitionNode, ObjectTypeDefinitionNode, InterfaceTypeDefinitionNode, NamedTypeNode, UnionTypeDefinitionNode, TypeDefinitionNode, DirectiveNode, EnumTypeDefinitionNode, InputObjectTypeDefinitionNode, DocumentNode, FragmentDefinitionNode, SelectionNode, FieldNode, InlineFragmentNode, OperationDefinitionNode } from 'graphql';
+/**
+ * the `gql` module provides functions and types which can be
+ * used to build up the GraphQL AST. The primary reason for us using
+ * this instead of the [builders provided by the graphql package](https://graphql.org/graphql-js/type/#examples)
+ * is due to the dynamic and asynchronous nature of our needs.
+ *
+ * The tradeoff is a low-level API that's often more verbose, and it's
+ * not a complete match of the GraphQL spec, so additional properties will likely
+ * be needed as our needs grow.
+ */
+export declare const astBuilder: {
+    /**
+     * `FormFieldBuilder` acts as a shortcut to building an entire `ObjectTypeDefinition`, we use this
+     * because all Tina field objects share a common set of fields ('name', 'label', 'component')
+     */
+    FormFieldBuilder: ({ name, additionalFields, }: {
+        name: string;
+        additionalFields?: FieldDefinitionNode[];
+    }) => ObjectTypeDefinitionNode;
+    ScalarTypeDefinition: ({ name, description, }: {
+        name: string;
+        description?: string;
+    }) => ScalarTypeDefinitionNode;
+    InputValueDefinition: ({ name, type, list, required, }: {
+        name: string;
+        type: string | InputObjectTypeDefinitionNode | EnumTypeDefinitionNode;
+        list?: boolean;
+        required?: boolean;
+    }) => InputValueDefinitionNode;
+    EnumDefinition: (props: {
+        name: string;
+        required?: boolean;
+        values: string[];
+    }) => EnumTypeDefinitionNode;
+    FieldNodeDefinition: ({ name, type, args, list, required, }: {
+        name: string;
+        type: string | TypeDefinitionNode;
+        required?: boolean;
+        list?: boolean;
+        args?: InputValueDefinitionNode[];
+    }) => FieldNode;
+    FieldDefinition: ({ name, type, args, list, required, }: {
+        name: string;
+        type: string | TypeDefinitionNode;
+        required?: boolean;
+        list?: boolean;
+        args?: InputValueDefinitionNode[];
+    }) => FieldDefinitionNode;
+    InterfaceTypeDefinition: ({ name, fields, description, }: {
+        name: string;
+        description?: string;
+        fields: FieldDefinitionNode[];
+    }) => InterfaceTypeDefinitionNode;
+    InputObjectTypeDefinition: ({ name, fields, }: {
+        name: string;
+        fields: InputValueDefinitionNode[] | ObjectTypeDefinitionNode[];
+    }) => InputObjectTypeDefinitionNode;
+    UnionTypeDefinition: ({ name, types, }: {
+        name: string;
+        types: (string | TypeDefinitionNode)[];
+    }) => UnionTypeDefinitionNode;
+    NamedType: ({ name }: {
+        name: string;
+    }) => NamedTypeNode;
+    ObjectTypeDefinition: ({ name, fields, interfaces, directives, args, }: {
+        name: string;
+        fields: FieldDefinitionNode[];
+        interfaces?: NamedTypeNode[];
+        directives?: DirectiveNode[];
+        args?: NamedTypeNode[];
+    }) => ObjectTypeDefinitionNode;
+    FieldWithSelectionSetDefinition: ({ name, selections, }: {
+        name: string;
+        selections: SelectionNode[];
+    }) => {
+        name: {
+            kind: "Name";
+            value: string;
+        };
+        kind: "Field";
+        selectionSet: {
+            kind: "SelectionSet";
+            selections: SelectionNode[];
+        };
+    };
+    InlineFragmentDefinition: ({ name, selections, }: {
+        name: string;
+        selections: SelectionNode[];
+    }) => InlineFragmentNode;
+    FragmentDefinition: ({ name, fragmentName, selections, }: {
+        name: string;
+        fragmentName: string;
+        selections: SelectionNode[];
+    }) => FragmentDefinitionNode;
+    TYPES: {
+        Scalar: (type: scalarNames) => string;
+        MultiCollectionDocument: string;
+        CollectionDocumentUnion: string;
+        String: string;
+        Reference: string;
+        Collection: string;
+        ID: string;
+        SystemInfo: string;
+        Boolean: string;
+        JSON: string;
+        Node: string;
+        PageInfo: string;
+        Connection: string;
+        Number: string;
+        Document: string;
+    };
+    QueryOperationDefinition: ({ queryName, fragName, }: {
+        queryName: string;
+        fragName: string;
+    }) => OperationDefinitionNode;
+    ListQueryOperationDefinition: ({ queryName, fragName, }: {
+        queryName: string;
+        fragName: string;
+    }) => OperationDefinitionNode;
+    toGraphQLAst: (ast: {
+        globalTemplates: TypeDefinitionNode[];
+        query: TypeDefinitionNode;
+        definitions: TypeDefinitionNode[];
+    }) => DocumentNode;
+};
+declare type scalarNames = 'string' | 'boolean' | 'datetime' | 'image' | 'text' | 'number';
+export declare const extractInlineTypes: (item: TypeDefinitionNode | TypeDefinitionNode[]) => TypeDefinitionNode[];
+export declare function walk(maybeNode: TypeDefinitionNode, visited?: WeakSet<object>): IterableIterator<TypeDefinitionNode>;
+export declare function addNamespaceToSchema<T extends object | string>(maybeNode: T, namespace?: string[]): T;
+export declare const NAMER: {
+    dataFilterTypeNameOn: (namespace: string[]) => string;
+    dataFilterTypeName: (namespace: string[]) => string;
+    dataMutationTypeNameOn: (namespace: string[]) => string;
+    dataMutationTypeName: (namespace: string[]) => string;
+    updateName: (namespace: string[]) => string;
+    createName: (namespace: string[]) => string;
+    queryName: (namespace: string[]) => string;
+    generateQueryListName: (namespace: string[]) => string;
+    fragmentName: (namespace: string[]) => string;
+    collectionTypeName: (namespace: string[]) => string;
+    documentTypeName: (namespace: string[]) => string;
+    dataTypeName: (namespace: string[]) => string;
+    referenceConnectionType: (namespace: string[]) => string;
+    referenceConnectionEdgesTypeName: (namespace: string[]) => string;
+};
+export {};

package/dist/build.d.ts

@@ -0,0 +1,19 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import type { TinaSchema } from './schema';
+import { Database } from './database';
+export declare const indexDB: ({ database, config, buildSDK, }: {
+    database: Database;
+    config: TinaSchema['config'];
+    buildSDK?: boolean;
+}) => Promise<void>;

package/dist/builder/index.d.ts

@@ -0,0 +1,254 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { Database } from '../database';
+import type { ObjectTypeDefinitionNode, InlineFragmentNode } from 'graphql';
+import type { TinaCloudCollectionEnriched, Template } from '../types';
+import { TinaSchema } from '../schema';
+export declare const createBuilder: ({ database, tinaSchema, }: {
+    database: Database;
+    tinaSchema: TinaSchema;
+}) => Promise<Builder>;
+/**
+ * The builder class is responsible for creating GraphQL AST definitions
+ * for a given portion of the Tina schema. In some cases that will also mean
+ * storing a reference to how we can resolve that type when we come across it.
+ */
+export declare class Builder {
+    config: {
+        database: Database;
+        tinaSchema: TinaSchema;
+    };
+    tinaSchema: TinaSchema;
+    database: Database;
+    constructor(config: {
+        database: Database;
+        tinaSchema: TinaSchema;
+    });
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getCollection(collection: $collection) {
+     *     name
+     *     documents {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildCollectionDefinition: (collections: TinaCloudCollectionEnriched[]) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getCollections {
+     *     name
+     *     documents {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildMultiCollectionDefinition: (collections: TinaCloudCollectionEnriched[]) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   node(id: $id) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     */
+    multiNodeDocument: () => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getDocument(collection: $collection, relativePath: $relativePath) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    multiCollectionDocument: (collections: TinaCloudCollectionEnriched[]) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * {
+     *    getDocumentFields()
+     * }
+     * ```
+     */
+    multiCollectionDocumentFields: () => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   addPendingDocument(collection: $collection, relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    addMultiCollectionDocumentMutation: () => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   createDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildCreateCollectionDocumentMutation: (collections: TinaCloudCollectionEnriched[]) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   updateDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    buildUpdateCollectionDocumentMutation: (collections: TinaCloudCollectionEnriched[]) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getDocumentList(first: 10) {
+     *     edges {
+     *       node {
+     *         id
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @param collections
+     */
+    multiCollectionDocumentList: (collections: TinaCloudCollectionEnriched[]) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getPostDocument(relativePath: $relativePath) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
+    collectionDocument: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * Turns a collection into a fragment that gets updated on build. This fragment does not resolve references
+     * ```graphql
+     * # ex.
+     * fragment AuthorsParts on Authors {
+     *   name
+     *   avatar
+     *   ...
+     * }
+     * ```
+     *
+     * @public
+     * @param collection a Tina Cloud collection
+     */
+    collectionFragment: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FragmentDefinitionNode>;
+    private _buildFieldNodeForFragments;
+    buildTemplateFragments(template: Template<true>): Promise<InlineFragmentNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * mutation {
+     *   updatePostDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
+    updateCollectionDocumentMutation: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * mutation {
+     *   createPostDocument(relativePath: $relativePath, params: $params) {
+     *     id
+     *     data {...}
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
+    createCollectionDocumentMutation: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * ```graphql
+     * # ex.
+     * {
+     *   getPostList(first: 10) {
+     *     edges {
+     *       node {
+     *         id
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @param collection
+     */
+    collectionDocumentList: (collection: TinaCloudCollectionEnriched) => Promise<import("graphql").FieldDefinitionNode>;
+    /**
+     * GraphQL type definitions which remain unchanged regardless
+     * of the supplied Tina schema. Ex. "node" interface
+     */
+    buildStaticDefinitions: () => (import("graphql").ScalarTypeDefinitionNode | ObjectTypeDefinitionNode | import("graphql").InterfaceTypeDefinitionNode[])[];
+    private _buildCollectionDocumentType;
+    private _filterCollectionDocumentType;
+    private _buildTemplateFilter;
+    private _updateCollectionDocumentMutationType;
+    private _buildTemplateMutation;
+    private _buildMultiCollectionDocumentDefinition;
+    private _buildMultiCollectionDocumentListDefinition;
+    private _buildFieldFilter;
+    private _buildFieldMutation;
+    private _buildReferenceMutation;
+    private _buildObjectOrUnionData;
+    private _connectionFilterBuilder;
+    private _connectionFieldBuilder;
+    private _buildDataField;
+    private _buildTemplateData;
+}

package/dist/builder/static-definitions.d.ts

@@ -0,0 +1,13 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export declare const staticDefinitions: (import("graphql").ScalarTypeDefinitionNode | import("graphql").ObjectTypeDefinitionNode | import("graphql").InterfaceTypeDefinitionNode[])[];

package/dist/database/bridge/index.d.ts

@@ -0,0 +1,23 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export interface Bridge {
+    rootPath: string;
+    glob(pattern: string): Promise<string[]>;
+    get(filepath: string): Promise<string>;
+    put(filepath: string, data: string): Promise<void>;
+    /**
+     * Whether this bridge supports the ability to build the schema.
+     */
+    supportsBuilding(): boolean;
+    putConfig(filepath: string, data: string): Promise<void>;
+}

package/dist/database/index.d.ts

@@ -0,0 +1,129 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import type { BinaryFilter, IndexDefinition, Store, TernaryFilter } from '@tinacms/datalayer';
+import type { DocumentNode } from 'graphql';
+import type { TinaSchema } from '../schema';
+import type { TinaCloudSchemaBase } from '../types';
+import type { Bridge } from './bridge';
+declare type CreateDatabase = {
+    bridge: Bridge;
+    store: Store;
+};
+export declare const createDatabase: (config: CreateDatabase) => Promise<Database>;
+/** Options for {@link Database.query} **/
+export declare type QueryOptions = {
+    collection: string;
+    filterChain?: (BinaryFilter | TernaryFilter)[];
+    sort?: string;
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+};
+export declare class Database {
+    config: CreateDatabase;
+    bridge: Bridge;
+    store: Store;
+    private tinaSchema;
+    private collectionIndexDefinitions;
+    private _lookup;
+    private _graphql;
+    private _tinaSchema;
+    constructor(config: CreateDatabase);
+    get: <T extends object>(filepath: string) => Promise<T>;
+    addPendingDocument: (filepath: string, data: {
+        [key: string]: unknown;
+    }) => Promise<void>;
+    put: (filepath: string, data: {
+        [key: string]: unknown;
+    }) => Promise<boolean>;
+    stringifyFile: (filepath: string, data: {
+        [key: string]: unknown;
+    }) => Promise<{
+        stringifiedFile: string;
+        payload: {
+            [key: string]: unknown;
+        };
+        keepTemplateKey: boolean;
+    }>;
+    flush: (filepath: string) => Promise<string>;
+    getLookup: (returnType: string) => Promise<LookupMapType>;
+    getGraphQLSchema: () => Promise<DocumentNode>;
+    getGraphQLSchemaFromBridge: () => Promise<DocumentNode>;
+    getTinaSchema: () => Promise<TinaCloudSchemaBase>;
+    getSchema: () => Promise<TinaSchema>;
+    getIndexDefinitions: () => Promise<Record<string, Record<string, IndexDefinition>>>;
+    documentExists: (fullpath: unknown) => Promise<boolean>;
+    query: (queryOptions: QueryOptions, hydrator: any) => Promise<{
+        edges: {
+            node: any;
+            cursor: string;
+        }[];
+        pageInfo: {
+            hasPreviousPage: boolean;
+            hasNextPage: boolean;
+            startCursor: string;
+            endCursor: string;
+        };
+    }>;
+    putConfigFiles: ({ graphQLSchema, tinaSchema, }: {
+        graphQLSchema: DocumentNode;
+        tinaSchema: TinaSchema;
+    }) => Promise<void>;
+    indexContent: ({ graphQLSchema, tinaSchema, }: {
+        graphQLSchema: DocumentNode;
+        tinaSchema: TinaSchema;
+    }) => Promise<void>;
+    indexContentByPaths: (documentPaths: string[]) => Promise<void>;
+    _indexAllContent: () => Promise<void>;
+    addToLookupMap: (lookup: LookupMapType) => Promise<void>;
+}
+export declare type LookupMapType = GlobalDocumentLookup | CollectionDocumentLookup | MultiCollectionDocumentLookup | MultiCollectionDocumentListLookup | CollectionDocumentListLookup | UnionDataLookup | NodeDocument;
+declare type NodeDocument = {
+    type: string;
+    resolveType: 'nodeDocument';
+};
+declare type GlobalDocumentLookup = {
+    type: string;
+    resolveType: 'globalDocument';
+    collection: string;
+};
+declare type CollectionDocumentLookup = {
+    type: string;
+    resolveType: 'collectionDocument';
+    collection: string;
+};
+declare type MultiCollectionDocumentLookup = {
+    type: string;
+    resolveType: 'multiCollectionDocument';
+    createDocument: 'create';
+    updateDocument: 'update';
+};
+declare type MultiCollectionDocumentListLookup = {
+    type: string;
+    resolveType: 'multiCollectionDocumentList';
+    collections: string[];
+};
+export declare type CollectionDocumentListLookup = {
+    type: string;
+    resolveType: 'collectionDocumentList';
+    collection: string;
+};
+declare type UnionDataLookup = {
+    type: string;
+    resolveType: 'unionData';
+    typeMap: {
+        [templateName: string]: string;
+    };
+};
+export {};

package/dist/database/util.d.ts

@@ -0,0 +1,16 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import * as yup from 'yup';
+export declare const stringifyFile: (content: object, format: FormatType | string, keepTemplateKey: boolean) => string;
+export declare const parseFile: <T extends object>(content: string, format: FormatType | string, yupSchema: (args: typeof yup) => yup.ObjectSchema<any>) => T;
+export declare type FormatType = 'json' | 'md' | 'mdx' | 'markdown';

package/dist/index.d.ts

@@ -1 +1,30 @@
-export * from "../src/index"
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export { indexDB } from './build';
+export { resolve } from './resolve';
+export { createDatabase } from './database';
+export type { QueryOptions } from './database';
+import type { Database } from './database';
+export type { Database } from './database';
+export type { Store } from '@tinacms/datalayer';
+export type { Bridge } from './database/bridge';
+export { sequential, assertShape } from './util';
+export { stringifyFile, parseFile } from './database/util';
+export declare const buildSchema: (rootPath: string, database: Database) => Promise<import("graphql").GraphQLSchema>;
+import type { TinaCloudSchema as TinaCloudSchemaBase, TinaCloudCollection as TinaCloudCollectionBase, TinaCloudTemplateBase as TinaTemplate, TinaFieldBase } from './types';
+export declare type TinaCloudSchema = TinaCloudSchemaBase<false>;
+export declare type TinaSchema = TinaCloudSchema;
+export declare type TinaCloudCollection = TinaCloudCollectionBase<false>;
+export declare type TinaCollection = TinaCloudCollectionBase<false>;
+export declare type TinaField = TinaFieldBase;
+export type { TinaTemplate };