@tinacms/graphql 0.55.1 → 0.57.0-hotfix

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # tina-graphql
 
+## 0.57.0
+
+### Minor Changes
+
+- ed277e3bd: Remove aws dependency and cache logic from GithubBridge
+- d1ed404ba: Add support for auto-generated SDK for type-safe data fetching
+
+### Patch Changes
+
+- 138ceb8c4: Clean up dependencies
+- 577d6a5ad: Adds collection arg back for generic queries as optional
+
+## 0.56.1
+
+### Patch Changes
+
+- 4b7795612: Adds support for collection.templates to TinaAdmin
+
+## 0.56.0
+
+### Minor Changes
+
+- b99baebf1: Add rich-text editor based on mdx, bump React dependency requirement to 16.14
+
+### Patch Changes
+
+- 891623c7c: Adds support for List and Update to TinaAdmin
+
+## 0.55.2
+
+### Patch Changes
+
+- 9ecb392ca: Fix bug which would set markdown body to undefined when the payload was emptry"
+
 ## 0.55.1
 
 ### Patch Changes

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/{cache/s3.d.ts → build.d.ts}

@@ -10,22 +10,10 @@ 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 { S3 } from 'aws-sdk';
-export declare const clearCacheWith: (cache: S3) => ({ owner, repo, ref, path, }: {
-    owner: string;
-    repo: string;
-    ref: string;
-    path?: string;
+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>;
-export declare const s3CacheWith: (cache: S3) => {
-    get: (keyName: string, setter: () => Promise<any>) => Promise<any>;
-};
-export declare const clearCache: ({ owner, repo, ref, path, }: {
-    owner: string;
-    repo: string;
-    ref: string;
-    path?: string;
-}) => Promise<void>;
-export declare const s3Cache: {
-    get: (keyName: string, setter: () => Promise<any>) => Promise<any>;
-};

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,99 @@
+/**
+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 { DocumentNode } from 'graphql';
+import type { TinaSchema } from '../schema';
+import type { TinaCloudSchemaBase } from '../types';
+import type { Store } from './store';
+import type { Bridge } from './bridge';
+declare type CreateDatabase = {
+    bridge: Bridge;
+    store: Store;
+};
+export declare const createDatabase: (config: CreateDatabase) => Promise<Database>;
+export declare class Database {
+    config: CreateDatabase;
+    bridge: Bridge;
+    store: Store;
+    private tinaSchema;
+    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;
+        };
+    }>;
+    flush: (filepath: string) => Promise<string>;
+    getLookup: (returnType: string) => Promise<LookupMapType>;
+    getGraphQLSchema: () => Promise<DocumentNode>;
+    getGraphQLSchemaFromBridge: () => Promise<DocumentNode>;
+    getTinaSchema: () => Promise<TinaCloudSchemaBase>;
+    getSchema: () => Promise<TinaSchema>;
+    documentExists: (fullpath: unknown) => Promise<boolean>;
+    query: (queryStrings: string[], hydrator: any) => Promise<object[]>;
+    indexData: ({ graphQLSchema, tinaSchema, }: {
+        graphQLSchema: DocumentNode;
+        tinaSchema: TinaSchema;
+    }) => 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/store/index.d.ts

@@ -0,0 +1,74 @@
+/**
+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 Store {
+    glob(pattern: string, hydrator?: (fullPath: string) => Promise<object>): Promise<string[]>;
+    get<T extends object>(filepath: string): Promise<T>;
+    clear(): void;
+    /**
+     *
+     * @param queryStrings
+     * Queries are currently structured as prefixed keys where that last portion
+     * of the key is the value provided by the query
+     * ```graphql
+     * {
+     *   getPostsList(filter: {
+     *     title: {
+     *       eq: "Hello, World"
+     *     }
+     *   }) {
+     *      ...
+     *   }
+     * }
+     * ```
+     * Would equate to a query string of:
+     * ```
+     * __attribute__#posts#posts#title#Hello, World
+     * ```
+     * This can be used by a data store as a secondary index of sorts
+     *
+     * It's important to note that for now each query string acts as an "AND" clause,
+     * meaning the resulting records need to be present in _each_ query string.
+     *
+     * @param hydrator
+     * hydrator is an optional callback, which may be useful depending on the storage mechanism.
+     * For example, the in-memory storage only stores the path to its records as its value,
+     * but in something like DynamoDB the query strings may be used to look up the full record,
+     * meaning there's no need to "hydrate" the return value
+     */
+    query(queryStrings: string[], hydrator?: (fullPath: string) => Promise<object>): Promise<object[]>;
+    /**
+     * In this context, seeding is the act of putting records and indexing data into an ephemeral
+     * storage layer for use during the GraphQL runtime. What might seem suprising is that some stores
+     * don't support seeding, this is because they're behaving more like a "bridge" (GithubStore and FilesystemStore).
+     * Currently they're acting as a way to swap out true data-layer behavior with a backwards-compatible
+     * "store". In the future, all stores should be able to query and seed data.
+     *
+     * At this time it seems that it would never make sense to be able to "query" without "seed"-ing, and
+     * there'd be no value in "seeding" without "query"-ing.
+     */
+    seed(filepath: string, data: object, options?: {
+        includeTemplate?: boolean;
+    }): Promise<void>;
+    supportsSeeding(): boolean;
+    /**
+     * Whether this store supports the ability to index data.
+     * Indexing data requires writing arbitrary keys/values to
+     * the external service, so is not advisable to use for
+     * something like Github, which would write commits to the
+     * user's repo.
+     */
+    supportsIndexing(): boolean;
+    put(filepath: string, data: object, options?: {
+        includeTemplate?: boolean;
+    }): Promise<void>;
+}