@takeshape/schema 12.1.1 → 12.1.4

package/dist/agents.d.ts

@@ -0,0 +1,62 @@
+import type { AgentJSON, AgentMap, GuardJSON, GuardMap, ProjectSchemaJSON, QueryJSON } from './project-schema/index.ts';
+/**
+ * Special transition destination ID for a newly created, never started session.
+ */
+export declare const AGENT_SESSION_CREATED = "SESSION_CREATED";
+/**
+ * Special transition destination ID for a started session.
+ */
+export declare const START_AGENT_EXECUTION = "START";
+/**
+ * Special transition destination ID for agent transitions that end the agent execution.
+ */
+export declare const END_AGENT_EXECUTION = "END";
+/**
+ * Special history strategy ID that indicates the history should be cleared.
+ */
+export declare const CLEAR_HISTORY_STRATEGY_ID = "clearHistory";
+export declare const EXECUTION_TYPE_CHAT = "chat";
+export declare const EXECUTION_TYPE_GENERATE = "generate";
+export declare const EXECUTION_TYPE_GRAPHQL = "graphql";
+export declare function getAgentEndStates(agent: AgentJSON, includeSuspend?: boolean): Set<string>;
+export declare const getCreateAgentSessionMutationName: (agentName: string) => string;
+export declare const getInspectAgentQueryName: (agentName: string) => string;
+export declare const getSendAgentFeedbackMutationName: (agentName: string) => string;
+export declare const getGetAgentMessageQueryName: (agentName: string) => string;
+export declare const getAbortAgentMessageMutationName: (agentName: string) => string;
+export declare const getSendAgentMessageMutationName: (inputName: string) => string;
+export declare function getAgentFeatures(agents: AgentMap): Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'shapes'>;
+export declare function isValidAgentMutation(projectSchema: ProjectSchemaJSON, name: string): boolean;
+export declare function addAiQueries(projectSchema: ProjectSchemaJSON): ProjectSchemaJSON;
+/**
+ * Where guards live in the schema.
+ */
+export declare const GUARDS_SCHEMA_PATH: readonly ["guards"];
+export declare const AGENTS_SCHEMA_PATH: readonly ["agents"];
+/**
+ * Check if a guard is enabled.
+ */
+export declare const isGuardEnabled: (guard: GuardJSON | undefined) => boolean;
+export declare function getGuardMap(schema: ProjectSchemaJSON): GuardMap | undefined;
+export declare function getGuards(schema: ProjectSchemaJSON): (GuardJSON & {
+    id: string;
+})[];
+export declare function setGuardMap<S extends Partial<ProjectSchemaJSON>>(schema: S, guards: GuardMap): S;
+export declare function setGuard<S extends Partial<ProjectSchemaJSON>>(schema: S, id: string, guard: GuardJSON): S;
+/**
+ * Get a guard configuration from the project schema.
+ */
+export declare function getGuardConfig(schema: ProjectSchemaJSON, guardId: string): GuardJSON | undefined;
+/**
+ * Get a guard configuration from the project schema, but only if it is enabled.
+ */
+export declare function getEnabledGuardConfig(schema: ProjectSchemaJSON, guardId: string): GuardJSON | undefined;
+export declare function getAgentMap(projectSchema: Pick<ProjectSchemaJSON, 'agents'>): AgentMap | undefined;
+export declare function getAgents(projectSchema: Pick<ProjectSchemaJSON, 'agents'>): (AgentJSON & {
+    name: string;
+})[] | undefined;
+export declare function setAgentMap<S extends Partial<ProjectSchemaJSON>>(projectSchema: S, agents: AgentMap): S;
+export declare function setAgent<S extends Partial<ProjectSchemaJSON>>(projectSchema: S, name: string, agent: AgentJSON): S;
+export declare function getAgent(projectSchema: ProjectSchemaJSON, name: string): AgentJSON | undefined;
+export declare function ensureAgent(projectSchema: ProjectSchemaJSON, name: string): AgentJSON;
+export declare function isAgentQuery(query: QueryJSON, agentName: string): boolean;

package/dist/agents.js

@@ -0,0 +1,346 @@
+import { assert } from '@takeshape/util';
+import set from 'lodash/fp/set.js';
+import get from 'lodash/get.js';
+import uniq from 'lodash/uniq.js';
+import upperFirst from 'lodash/upperFirst.js';
+import * as abortAgentMessageResponse from "./resolvers/ai/abort-agent-message-response.js";
+import * as agentChatPayload from "./resolvers/ai/agent-chat-payload.js";
+import * as agentSessionPayload from "./resolvers/ai/agent-session-payload.js";
+import * as getAgentMessageArgs from "./resolvers/ai/get-agent-message-args.js";
+import * as getAgentMessageResponse from "./resolvers/ai/get-agent-message-response.js";
+import * as inspectAgentArgs from "./resolvers/ai/inspect-agent-args.js";
+import * as inspectAgentResponse from "./resolvers/ai/inspect-agent-response.js";
+import * as sendAgentFeedbackArgs from "./resolvers/ai/send-agent-feedback-args.js";
+import * as sendAgentMessageArgs from "./resolvers/ai/send-agent-message-args.js";
+import * as sendAgentMessageResponse from "./resolvers/ai/send-agent-message-response.js";
+import { JSON_SHAPE_NAME } from "./resolvers/takeshape/builtins/constants.js";
+/**
+ * Special transition destination ID for a newly created, never started session.
+ */
+export const AGENT_SESSION_CREATED = 'SESSION_CREATED';
+/**
+ * Special transition destination ID for a started session.
+ */
+export const START_AGENT_EXECUTION = 'START';
+/**
+ * Special transition destination ID for agent transitions that end the agent execution.
+ */
+export const END_AGENT_EXECUTION = 'END';
+/**
+ * Special history strategy ID that indicates the history should be cleared.
+ */
+export const CLEAR_HISTORY_STRATEGY_ID = 'clearHistory';
+export const EXECUTION_TYPE_CHAT = 'chat';
+export const EXECUTION_TYPE_GENERATE = 'generate';
+export const EXECUTION_TYPE_GRAPHQL = 'graphql';
+function canEndOnState(state, includeSuspend = false) {
+    const { transitions } = state;
+    if (!transitions?.length) {
+        return true;
+    }
+    for (const step of transitions) {
+        if (includeSuspend && step.type === 'suspend') {
+            return true;
+        }
+        if (step.destination === END_AGENT_EXECUTION) {
+            return true;
+        }
+        if (step.condition === undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+export function getAgentEndStates(agent, includeSuspend = false) {
+    const endStates = new Set();
+    for (const [stateId, state] of Object.entries(agent.states)) {
+        if (canEndOnState(state, includeSuspend)) {
+            endStates.add(stateId);
+        }
+    }
+    return endStates;
+}
+// Agent Scoped Names
+export const getCreateAgentSessionMutationName = (agentName) => {
+    return `create${upperFirst(agentName)}Session`;
+};
+export const getInspectAgentQueryName = (agentName) => {
+    return `inspect${upperFirst(agentName)}`;
+};
+export const getSendAgentFeedbackMutationName = (agentName) => {
+    return `send${upperFirst(agentName)}Feedback`;
+};
+export const getGetAgentMessageQueryName = (agentName) => {
+    return `get${upperFirst(agentName)}Message`;
+};
+export const getAbortAgentMessageMutationName = (agentName) => {
+    return `abort${upperFirst(agentName)}Message`;
+};
+// Agent Input Scopes Names
+export const getSendAgentMessageMutationName = (inputName) => {
+    return `send${upperFirst(inputName)}Message`;
+};
+function createAssertValidName(key, result) {
+    const singular = key === 'shapes' ? 'shape' : key === 'mutations' ? 'mutation' : 'query';
+    return (name) => {
+        assert(result[key][name] === undefined, `Schema already has a ${singular} with the name "${name}"`);
+    };
+}
+export function getAgentFeatures(agents) {
+    const result = {
+        queries: {},
+        mutations: {},
+        shapes: {}
+    };
+    const assertValidShapeName = createAssertValidName('shapes', result);
+    const assertValidQueryName = createAssertValidName('queries', result);
+    const assertValidMutationName = createAssertValidName('mutations', result);
+    for (const [agentName, agent] of Object.entries(agents)) {
+        // Get valid return types based on states that could possibly be the end state
+        // TODO In the future the agent will have a return type defined and we will instead validate
+        // that all the return states will return the correct shape.
+        const returnStates = [...getAgentEndStates(agent, true)];
+        const returnTypes = uniq(returnStates.map((stateId) => {
+            const { execution } = agent.states[stateId];
+            if (execution.type === EXECUTION_TYPE_CHAT) {
+                return agentChatPayload.shapeName;
+            }
+            if (execution.type === EXECUTION_TYPE_GENERATE) {
+                return execution.outputShape ? execution.outputShape : 'string';
+            }
+            return JSON_SHAPE_NAME;
+        }));
+        const agentOutput = returnTypes.length === 0 ? 'string' : returnTypes.length === 1 ? returnTypes[0] : JSON_SHAPE_NAME;
+        const agentOutputSchema = agentOutput === 'string' ? { type: 'string' } : { '@ref': agentOutput };
+        const agentSessionShapeName = agentSessionPayload.shapeName;
+        const agentMessageShapeName = getAgentMessageResponse.createUserShapeName(agentName);
+        assertValidShapeName(agentMessageShapeName);
+        result.shapes[agentMessageShapeName] = {
+            id: agentMessageShapeName,
+            name: agentMessageShapeName,
+            title: agentMessageShapeName,
+            schema: getAgentMessageResponse.createUserShapeSchema({
+                properties: {
+                    output: agentOutputSchema
+                }
+            })
+        };
+        const sendAgentMessageResponseShapeName = sendAgentMessageResponse.createUserShapeName(agentName);
+        assertValidShapeName(sendAgentMessageResponseShapeName);
+        result.shapes[sendAgentMessageResponseShapeName] = {
+            id: sendAgentMessageResponseShapeName,
+            name: sendAgentMessageResponseShapeName,
+            title: sendAgentMessageResponseShapeName,
+            schema: sendAgentMessageResponse.createUserShapeSchema({
+                properties: {
+                    output: agentOutputSchema
+                }
+            })
+        };
+        const inspectAgentResponseShapeName = inspectAgentResponse.createUserShapeName(agentName);
+        assertValidShapeName(inspectAgentResponseShapeName);
+        result.shapes[inspectAgentResponseShapeName] = {
+            id: inspectAgentResponseShapeName,
+            name: inspectAgentResponseShapeName,
+            title: inspectAgentResponseShapeName,
+            schema: inspectAgentResponse.createUserShapeSchema()
+        };
+        const getAgentMessageQueryName = getGetAgentMessageQueryName(agentName);
+        assertValidQueryName(getAgentMessageQueryName);
+        result.queries[getAgentMessageQueryName] = {
+            description: `Get a message for the ${agentName} agent`,
+            shape: agentMessageShapeName,
+            resolver: {
+                name: 'ai:getAgentMessage',
+                agentName
+            },
+            args: {
+                ...getAgentMessageArgs.schema
+            }
+        };
+        const abortAgentMessageMutationName = getAbortAgentMessageMutationName(agentName);
+        assertValidMutationName(abortAgentMessageMutationName);
+        result.mutations[abortAgentMessageMutationName] = {
+            description: `Abort a message for the ${agentName} agent`,
+            shape: abortAgentMessageResponse.shapeName,
+            resolver: {
+                name: 'ai:abortAgentMessage',
+                agentName
+            },
+            args: {
+                ...getAgentMessageArgs.schema
+            }
+        };
+        const createAgentSessionMutationName = getCreateAgentSessionMutationName(agentName);
+        assertValidMutationName(createAgentSessionMutationName);
+        result.mutations[createAgentSessionMutationName] = {
+            description: `Create a session for the ${agentName} agent`,
+            shape: agentSessionShapeName,
+            resolver: {
+                name: 'ai:createAgentSession',
+                agentName
+            }
+        };
+        const inspectAgentQueryName = getInspectAgentQueryName(agentName);
+        assertValidQueryName(inspectAgentQueryName);
+        result.queries[inspectAgentQueryName] = {
+            description: `Inspect the ${agentName} agent`,
+            args: inspectAgentArgs.schema,
+            shape: inspectAgentResponseShapeName,
+            resolver: {
+                name: 'ai:inspectAgent',
+                agentName
+            }
+        };
+        result.mutations[getSendAgentFeedbackMutationName(agentName)] ||= {
+            description: `Send feedback for the ${agentName} agent`,
+            args: sendAgentFeedbackArgs.shapeName,
+            shape: 'boolean',
+            resolver: {
+                name: 'ai:sendAgentFeedback',
+                agentName
+            }
+        };
+        // This mutation can vary depending on the inputs defined, everything else is stable for the whole agent (for now)
+        for (const inputConfig of agent.api.inputs) {
+            if (inputConfig.type === 'mutation') {
+                const inputName = inputConfig.name;
+                const sendAgentMessageMutationName = getSendAgentMessageMutationName(inputName);
+                assertValidMutationName(sendAgentMessageMutationName);
+                result.mutations[sendAgentMessageMutationName] = {
+                    description: agent.description,
+                    args: {
+                        type: 'object',
+                        extends: [
+                            {
+                                ...sendAgentMessageArgs.shapeSchema,
+                                required: agent.protection?.enabled
+                                    ? [...sendAgentMessageArgs.shapeSchema.required, 'token']
+                                    : sendAgentMessageArgs.shapeSchema.required
+                            },
+                            {
+                                '@ref': inputConfig.args
+                            }
+                        ]
+                    },
+                    shape: sendAgentMessageResponseShapeName,
+                    resolver: {
+                        name: 'ai:sendAgentMessage',
+                        agentName,
+                        inputName
+                    }
+                };
+            }
+        }
+    }
+    return result;
+}
+export function isValidAgentMutation(projectSchema, name) {
+    const agents = getAgents(projectSchema);
+    if (agents) {
+        for (const agent of agents) {
+            if (getSendAgentFeedbackMutationName(agent.name) === name ||
+                getCreateAgentSessionMutationName(agent.name) === name ||
+                getAbortAgentMessageMutationName(agent.name) === name) {
+                return true;
+            }
+            for (const input of agent.api.inputs) {
+                if (input.type === 'mutation' && getSendAgentMessageMutationName(input.name) === name) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+export function addAiQueries(projectSchema) {
+    const agents = getAgentMap(projectSchema);
+    if (!agents) {
+        return projectSchema;
+    }
+    const aiFeatures = getAgentFeatures(agents);
+    return {
+        ...projectSchema,
+        queries: {
+            ...projectSchema.queries,
+            ...aiFeatures.queries
+        },
+        mutations: {
+            ...projectSchema.mutations,
+            ...aiFeatures.mutations
+        },
+        shapes: {
+            ...projectSchema.shapes,
+            ...aiFeatures.shapes
+        }
+    };
+}
+/**
+ * Where guards live in the schema.
+ */
+export const GUARDS_SCHEMA_PATH = ['guards'];
+export const AGENTS_SCHEMA_PATH = ['agents'];
+/**
+ * Check if a guard is enabled.
+ */
+export const isGuardEnabled = (guard) => {
+    return Boolean(guard && guard.enabled !== false);
+};
+export function getGuardMap(schema) {
+    return schema.guards;
+}
+export function getGuards(schema) {
+    const guards = getGuardMap(schema);
+    return guards ? Object.entries(guards).map(([id, guard]) => ({ id, ...guard })) : [];
+}
+export function setGuardMap(schema, guards) {
+    return set(GUARDS_SCHEMA_PATH, guards, schema);
+}
+export function setGuard(schema, id, guard) {
+    return set([...GUARDS_SCHEMA_PATH, id], guard, schema);
+}
+/**
+ * Get a guard configuration from the project schema.
+ */
+export function getGuardConfig(schema, guardId) {
+    return get(schema, [...GUARDS_SCHEMA_PATH, guardId]);
+}
+/**
+ * Get a guard configuration from the project schema, but only if it is enabled.
+ */
+export function getEnabledGuardConfig(schema, guardId) {
+    const config = getGuardConfig(schema, guardId);
+    if (config && isGuardEnabled(config)) {
+        return config;
+    }
+}
+export function getAgentMap(projectSchema) {
+    return projectSchema.agents;
+}
+export function getAgents(projectSchema) {
+    const agentMap = getAgentMap(projectSchema);
+    return agentMap && Object.entries(agentMap).map(([name, agent]) => ({ name, ...agent }));
+}
+export function setAgentMap(projectSchema, agents) {
+    return set(AGENTS_SCHEMA_PATH, agents, projectSchema);
+}
+export function setAgent(projectSchema, name, agent) {
+    return set([...AGENTS_SCHEMA_PATH, name], agent, projectSchema);
+}
+export function getAgent(projectSchema, name) {
+    return getAgentMap(projectSchema)?.[name];
+}
+export function ensureAgent(projectSchema, name) {
+    const agent = getAgent(projectSchema, name);
+    if (!agent) {
+        throw new Error(`Agent "${name}" not found`);
+    }
+    return agent;
+}
+export function isAgentQuery(query, agentName) {
+    const resolver = query.resolver;
+    if ('agentName' in resolver) {
+        return resolver.agentName === agentName;
+    }
+    return false;
+}

package/dist/api-version.d.ts

@@ -0,0 +1,5 @@
+import type SemVer from 'semver/classes/semver.js';
+export type VersionCompareFn = (apiVersion: string | SemVer, featureVersion: string | SemVer) => boolean;
+export declare const createVersionPredicate: (featureVersion: string | SemVer, comparison: VersionCompareFn) => ((apiVersion: string | SemVer) => boolean);
+export declare const workflowsEnabled: (apiVersion: string | SemVer) => boolean;
+export declare const whereClauseEnabled: (apiVersion: string | SemVer) => boolean;

package/dist/api-version.js

@@ -0,0 +1,17 @@
+import coerce from 'semver/functions/coerce.js';
+import gte from 'semver/functions/gte.js';
+export const createVersionPredicate = (featureVersion, comparison) => {
+    const coercedFeatureVersion = coerce(featureVersion);
+    if (!coercedFeatureVersion) {
+        throw new Error(`Could not create predicate version "${featureVersion}" is not valid`);
+    }
+    return (apiVersion) => {
+        const coercedApiVersion = coerce(apiVersion);
+        if (!coercedApiVersion) {
+            throw new Error(`Version "${apiVersion}" is not valid and could not be coerced`);
+        }
+        return comparison(coercedApiVersion, coercedFeatureVersion);
+    };
+};
+export const workflowsEnabled = createVersionPredicate('2.0.0', gte);
+export const whereClauseEnabled = createVersionPredicate('2.0.0', gte);

package/dist/auth-schemas.d.ts

@@ -0,0 +1,144 @@
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+/**
+ * A role import document is an array of role
+ *
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "RoleImport".
+ */
+export type RoleImport = RoleInput[];
+export interface AuthSchemas {
+    [k: string]: any;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "Condition".
+ */
+export interface Condition {
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "Statement".
+ */
+export interface Statement {
+    Effect?: 'Allow' | 'Deny';
+    Sid?: string;
+    Action?: string[];
+    NotAction?: string[];
+    Resource?: string[];
+    NotResource?: string[];
+    Principal?: {
+        AWS?: string[];
+        Service?: string[];
+    };
+    Condition?: Condition;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "AccessPolicyDocument".
+ */
+export interface AccessPolicyDocument {
+    Version: string;
+    Statement: Statement[];
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "ApiKey".
+ */
+export interface ApiKey {
+    projectId: string;
+    name: string;
+    role?: string;
+    permissions?: AccessPolicyDocument;
+    lastUsed?: string;
+    apiKey?: string;
+    id: string;
+    delinquent?: boolean;
+    apiRateLimit?: number;
+    deactivated?: number;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "UserPermission".
+ */
+export interface UserPermission {
+    projectId: string;
+    userId: string;
+    role: string;
+    permissions?: AccessPolicyDocument;
+    created?: number;
+    updated?: number;
+    deactivated?: number;
+    delinquent?: boolean;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "Role".
+ */
+export interface Role {
+    projectId: string;
+    name: string;
+    conditions?: Condition;
+    permissions: AccessPolicyDocument;
+    builtIn?: boolean;
+    created?: number;
+    updated?: number;
+}
+/**
+ * Input type for role creation and updates.
+ *
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "RoleInput".
+ */
+export interface RoleInput {
+    projectId?: string;
+    name: string;
+    conditions?: Condition;
+    permissions: AccessPolicyDocument;
+    builtIn?: boolean;
+    created?: number;
+    updated?: number;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "BigCommerceAppSettings".
+ */
+export interface BigCommerceAppSettings {
+    verified?: boolean;
+    emailValidationToken?: string | null;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "AppSettings".
+ */
+export interface AppSettings {
+    bigcommerce?: BigCommerceAppSettings;
+}
+/**
+ * This interface was referenced by `AuthSchemas`'s JSON-Schema
+ * via the `definition` "User".
+ */
+export interface User {
+    id: string;
+    email: string;
+    fullName: string;
+    created: number;
+    updated: number;
+    requiresEmailValidation?: boolean;
+    emailValidationToken?: string;
+    appSettings?: AppSettings;
+    inviteCode?: string;
+    firstTime: boolean;
+    avatarPath?: string;
+    intercomHash?: string;
+    googleUserId?: string;
+    comcastId?: string;
+    token?: string;
+    policies?: AccessPolicyDocument[];
+    preferences?: {
+        [k: string]: any;
+    };
+}

package/dist/auth-schemas.js

@@ -0,0 +1,7 @@
+/* tslint:disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+export {};

package/dist/auth-utils.d.ts

@@ -0,0 +1,19 @@
+import type { User } from './auth-schemas.ts';
+/**
+ * Check if user requires email validaiton with proper fallback for older accounts.
+ */
+export declare const userRequiresEmailValidation: (user: User) => boolean;
+/**
+ * Check if user requires BigCommerce email verification.
+ * Returns true if verified is explicitly false (user has started BC flow but not verified).
+ * Returns false if verified is true or undefined (never used BC, or already verified).
+ */
+export declare const userRequiresBcVerification: (user: User) => boolean;
+/**
+ * Check if user has completed BigCommerce email verification.
+ */
+export declare const userIsBcVerified: (user: User) => boolean;
+/**
+ * Get the BigCommerce email validation token.
+ */
+export declare const getBcEmailValidationToken: (user: User) => string | null | undefined;

package/dist/auth-utils.js

@@ -0,0 +1,26 @@
+/**
+ * Check if user requires email validaiton with proper fallback for older accounts.
+ */
+export const userRequiresEmailValidation = (user) => {
+    return user.requiresEmailValidation === true;
+};
+/**
+ * Check if user requires BigCommerce email verification.
+ * Returns true if verified is explicitly false (user has started BC flow but not verified).
+ * Returns false if verified is true or undefined (never used BC, or already verified).
+ */
+export const userRequiresBcVerification = (user) => {
+    return user.appSettings?.bigcommerce?.verified === false;
+};
+/**
+ * Check if user has completed BigCommerce email verification.
+ */
+export const userIsBcVerified = (user) => {
+    return user.appSettings?.bigcommerce?.verified === true;
+};
+/**
+ * Get the BigCommerce email validation token.
+ */
+export const getBcEmailValidationToken = (user) => {
+    return user.appSettings?.bigcommerce?.emailValidationToken;
+};

package/dist/builtin-schema.d.ts

@@ -0,0 +1,18 @@
+import type { Entitlements } from '@takeshape/util';
+import type { FormMap, ShapeJSON, ShapeMap } from './project-schema/index.ts';
+import type { Content } from './types/index.ts';
+export type SchemaDefaultsOptions = {
+    entitlements: Pick<Entitlements, 'staticSites'>;
+};
+export declare function isAsset(content: Content): boolean;
+export declare function getAssetS3Path(content: Content): string | undefined;
+export declare function setAssetS3Path(content: Content, path: string): void;
+export declare const jsonShape: ShapeJSON;
+export declare function getBuiltInShapes(options: SchemaDefaultsOptions): ShapeMap;
+export declare function getBuiltInForms(options: SchemaDefaultsOptions): FormMap;
+export declare const allBuiltInShapes: {
+    [x: string]: ShapeJSON;
+};
+export declare const allBuiltInForms: {
+    [x: string]: import("./project-schema/latest.ts").FormsConfig;
+};