@takeshape/schema 11.40.0 → 11.41.0

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

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

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

@@ -0,0 +1,37 @@
+import type { Maybe } from '@takeshape/util';
+import type { PropertySchema, ProjectSchemaJSON, ShapeJSON, ObjectSchema, ShapeMap } from '../project-schema';
+import type { ResolvedTemplate } from './types';
+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 {};

package/dist/types/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './utils';
+export * from './transforms';

package/dist/types/src/types/transforms.d.ts

@@ -0,0 +1,13 @@
+import { type ShapeJSON, type PropertySchema } from '../project-schema';
+export type ContentTransform = (schema: PropertySchema, obj: unknown, name?: string) => unknown;
+export type SourceKeyTransform = (name: string, schema: PropertySchema, parent: unknown) => string | string[];
+export type KeyTransform = (name: string, schema: PropertySchema, sourceKey?: string) => string;
+export type PropertyTransform = {
+    keyTransform?: KeyTransform;
+    filter(schema: PropertySchema, name: string, shape?: ShapeJSON): boolean;
+    process(value: unknown, schema: PropertySchema, name: string, shape: ShapeJSON | undefined, next: (value: unknown, schema: PropertySchema, name: string) => unknown): unknown;
+};
+export type SchemaType = '*' | 'object' | 'array' | 'string' | 'number' | 'integer' | 'boolean';
+export type PropertyTransformMap = {
+    [key in SchemaType]?: PropertyTransform[];
+};

package/dist/types/src/types/types.d.ts

@@ -0,0 +1,210 @@
+import type { SetRequired, Merge, PartialDeep, SetOptional } from 'type-fest';
+import type { Overwrite } from '@takeshape/util';
+import { type XMLParser } from 'fast-xml-parser';
+import type { ProjectSchemaJSON, ProjectSchemaJSONV1_0_0, ProjectSchemaJSONV3_0_0, ProjectSchemaJSONV3_1_0, ProjectSchemaJSONV3_2_0, ProjectSchemaJSONV3_3_0, ProjectSchemaJSONV3_4_0, ProjectSchemaJSONV3_5_0, ProjectSchemaJSONV3_5_1, ProjectSchemaJSONV3_6_0, ProjectSchemaJSONV3_7_0, ProjectSchemaJSONV3_8_0, ProjectSchemaJSONV3_9_0, ProjectSchemaJSONV3_10_0, ProjectSchemaJSONV3_11_0, ProjectSchemaJSONV3_12_0, ProjectSchemaJSONV3_12_1, ProjectSchemaJSONV3_12_2, ProjectSchemaJSONV3_12_3, ProjectSchemaJSONV3_13_0, ProjectSchemaJSONV3_14_0, ProjectSchemaJSONV3_15_0, ProjectSchemaJSONV3_16_0, ProjectSchemaJSONV3_17_0, ProjectSchemaJSONV3_17_1, ProjectSchemaJSONV3_18_0, ProjectSchemaJSONV3_18_1, ProjectSchemaJSONV3_18_2, ProjectSchemaJSONV3_19_0, ProjectSchemaJSONV3_20_0, ProjectSchemaJSONV3_21_0, ProjectSchemaJSONV3_22_0, ProjectSchemaJSONV3_23_0, QueryJSON, PropertySchema, ServiceMapJSON, ServiceConfig, OAuth2Authentication, CustomAuthentication, ServiceAuthentication, AnyProjectSchemaJSON, Ref, CachedFragmentConfig, ListQueryLoaderConfig, GetQueryLoaderConfig, ShapeJSON } from '../project-schema';
+import { type SERVICE_OBJECT_PATTERN_NAME } from '../constants';
+export type ProjectSchemaJSONWithVersion = ProjectSchemaJSONV3_23_0 | ProjectSchemaJSONV3_22_0 | ProjectSchemaJSONV3_21_0 | ProjectSchemaJSONV3_20_0 | ProjectSchemaJSONV3_19_0 | ProjectSchemaJSONV3_18_2 | ProjectSchemaJSONV3_18_1 | ProjectSchemaJSONV3_18_0 | ProjectSchemaJSONV3_17_1 | ProjectSchemaJSONV3_17_0 | ProjectSchemaJSONV3_16_0 | ProjectSchemaJSONV3_15_0 | ProjectSchemaJSONV3_14_0 | ProjectSchemaJSONV3_13_0 | ProjectSchemaJSONV3_12_3 | ProjectSchemaJSONV3_12_2 | ProjectSchemaJSONV3_12_1 | ProjectSchemaJSONV3_12_0 | ProjectSchemaJSONV3_11_0 | ProjectSchemaJSONV3_10_0 | ProjectSchemaJSONV3_9_0 | ProjectSchemaJSONV3_8_0 | ProjectSchemaJSONV3_7_0 | ProjectSchemaJSONV3_6_0 | ProjectSchemaJSONV3_5_1 | ProjectSchemaJSONV3_5_0 | ProjectSchemaJSONV3_4_0 | ProjectSchemaJSONV3_3_0 | ProjectSchemaJSONV3_2_0 | ProjectSchemaJSONV3_1_0 | ProjectSchemaJSONV3_0_0 | ProjectSchemaJSONV1_0_0;
+export declare const projectSchemaImportOptionalProps: readonly ["projectId", "locales", "defaultLocale", "author"];
+export declare const legacyProjectSchemaImportOptionalProps: readonly ["created", "updated", "version", "dataKey"];
+export type ProjectSchemaImport = SetOptional<AnyProjectSchemaJSON, (typeof projectSchemaImportOptionalProps)[number]>;
+export type Content = {
+    [name: string]: any;
+    _id: string;
+};
+export type ServiceInfo = {
+    service: string;
+    fieldName: string;
+    path: string[];
+    generators: Record<typeof SERVICE_OBJECT_PATTERN_NAME, PatternGenerator | undefined>;
+};
+/**
+ * Remote service configuration types
+ */
+/**
+ * Old service authentication
+ * @deprecated
+ */
+export type ServiceConfigAccessToken = {
+    accessToken: string;
+    refreshToken?: string;
+    scope?: string;
+};
+export type ServiceKey = string;
+export type ServiceMap = Map<ServiceKey, ServiceConfig>;
+export type PatternGenerator = {
+    version: string;
+    currentVersion: string;
+    idFieldName: string;
+    serviceObjectType: string;
+};
+export type Headers = Record<string, string | string[]>;
+type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'HEAD' | 'DELETE' | 'OPTIONS' | 'TRACE' | 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'trace';
+export type AllowedRetryOptions = number | Partial<{
+    limit: number;
+    methods: Method[];
+    statusCodes: number[];
+    errorCodes: string[];
+    maxRetryAfter: number;
+    backoffLimit: number;
+    noise: number;
+}>;
+export type RESTServiceConfig = Overwrite<ServiceConfig, {
+    serviceType: 'rest';
+    options: {
+        [name: string]: any;
+        endpoint: string;
+        headers?: Headers;
+        timeout?: number;
+        retry?: AllowedRetryOptions;
+        fastXmlParser?: ConstructorParameters<typeof XMLParser>[0];
+    };
+}>;
+export type GraphQLServiceConfig = Overwrite<ServiceConfig, {
+    serviceType: 'graphql';
+    options: {
+        [name: string]: any;
+        endpoint: string;
+        headers?: Headers;
+        timeout?: number;
+    };
+}>;
+export type OpenAPIServiceConfig = Merge<ServiceConfig, {
+    serviceType: 'openapi';
+    options: {
+        [name: string]: any;
+        endpoint: string;
+        spec: string;
+        headers?: Headers;
+        timeout?: number;
+        retry?: AllowedRetryOptions;
+        useRestfulNames?: boolean;
+        introspectedAt?: string;
+        transformVersion?: string;
+    };
+}>;
+export type EncryptedServiceConfig = Overwrite<ServiceConfig, {
+    authentication: string;
+}>;
+export type ServiceConfigWithOAuth2Authentication = Merge<ServiceConfig, {
+    authentication: OAuth2Authentication;
+}>;
+export type ServiceConfigWithCustomAuthentication = Merge<ServiceConfig, {
+    authentication: CustomAuthentication;
+}>;
+/**
+ * Support null sentinels for authentication
+ */
+export type ServiceConfigWithNullSentinelAuthentication = Overwrite<ServiceConfig, {
+    authentication?: ServiceAuthentication | null;
+}>;
+/**
+ * A type suitable for service object updates, mostly concerns authentication
+ * requirements.
+ */
+export type ServiceConfigUpdate = SetRequired<PartialDeep<ServiceConfigWithNullSentinelAuthentication>, 'authenticationType'>;
+export type LatestProjectSchemaWithServices = {
+    services: ServiceMapJSON;
+} & ProjectSchemaJSON;
+/**
+ * Types of refs
+ */
+export declare enum RefType {
+    '@ref' = "@ref",
+    $ref = "$ref"
+}
+/**
+ * Stub of a PropertySchema that may contain a `$ref` or `@ref`.
+ */
+export type RefSchemaStub = {
+    items?: RefSchemaStub;
+} & Pick<PropertySchema, RefType>;
+export type SchemaWithRef = PropertySchema | RefSchemaStub;
+/**
+ * Types of args
+ */
+export declare enum ArgsType {
+    '@args' = "@args",
+    args = "args"
+}
+export type SchemaWithArgs = PropertySchema | QueryJSON;
+/**
+ * Types supporting schema iterators
+ */
+export type SchemaPropertyName = string;
+export type SchemaPropertyNode = [SchemaPropertyName, PropertySchema];
+export type SchemaPropertyIterator = SchemaPropertyNode[];
+export type ShopifyServiceConfig = Overwrite<ServiceConfig, {
+    serviceType: 'graphql';
+    provider: 'shopify';
+    options: {
+        shop: string;
+        endpoint: string;
+    };
+}>;
+export type SchemaPath = Array<string | number>;
+export type LayerSchema = Pick<ProjectSchemaJSON, 'shapes' | 'queries' | 'mutations' | 'schemaVersion'>;
+export type UndefinedLayerState = {
+    id: string;
+    schema: undefined;
+    status: 'disconnected' | 'error' | 'notAvailable';
+};
+export type DefinedLayerState = {
+    id: string;
+    schema: LayerSchema;
+    status: 'ok';
+};
+export type LayerState = UndefinedLayerState | DefinedLayerState;
+export type LayerStatus = LayerState['status'];
+export type UndefinedLayerStatus = UndefinedLayerState['status'];
+/**
+ * Shapes
+ */
+export type ShapeRefs = Ref[];
+/**
+ * Relationships
+ */
+export type PropertySchemaWithRelationship = PropertySchema & {
+    '@resolver': {
+        name: 'shapedb:getRelated';
+        service: 'shapedb';
+        options?: {
+            nullable?: boolean;
+        };
+    };
+};
+/**
+ * New relationship data, drawn from a PropertySchema.
+ */
+export type Relationship = {
+    isMultiple: boolean;
+    refs: ShapeRefs;
+    hasBackreference: boolean;
+    backreferenceName?: string;
+};
+/**
+ * The old relationship format, used in client UI.
+ */
+export type LegacyRelationship = {
+    shapeIds: string[];
+    type?: 'single' | 'multiple';
+};
+export type RelationshipEnv = {
+    shapeId: string;
+    path: string[];
+    hasBackreference: boolean;
+    relatedName?: string;
+    schema: PropertySchema;
+    shapeName: string;
+};
+export type CachedShape = SetRequired<ShapeJSON, 'loaders' | 'cache'>;
+export type CachedShapeMap = Record<string, CachedShape>;
+export type ListQueryIndexingConfig = CachedFragmentConfig & ListQueryLoaderConfig & {
+    shapeName: string;
+    idField: string;
+};
+export type GetQueryIndexingConfig = CachedFragmentConfig & GetQueryLoaderConfig & {
+    shapeName: string;
+    idField: string;
+};
+export type MeshShape = SetRequired<ShapeJSON, 'joins'>;
+export {};

package/dist/types/src/types/utils.d.ts

@@ -0,0 +1,117 @@
+import type { Maybe } from '@takeshape/util';
+import { type ProjectSchemaJSON, type DirectiveMappingArray, type DirectiveMappingMap, type DirectiveConfig, type ParameterSerializeOptions, type ParameterSerializeContentOptions, type ParameterSerializeStyleOptions, type BasicResolver, type ComposeResolver, type GraphqlResolver, type TakeshapeResolver, type ShapedbResolver, type RestResolver, type AwsLambdaResolver, type UtilResolver, type ObjectSchema, type ReturnShapeArraySchema, type ShapeSchemaEnum, type RefSchema, type RefSchemaLegacy, type PropertySchema, type AnyServiceConfig, type ServiceAuthentication, type BearerAuthentication, type BasicAuthentication, type OAuth2Authentication, type OAuth2BearerAuthentication, type SearchParamsAuthentication, type CustomAuthentication, type ParameterOp, type ParameterOpNested, type ParameterOpMapping, type ParameterOpValue, type ParameterOpOp, type ParameterSerializeStyleOptionsForSearchParams, type ParameterSerializeStyleOptionsForPathParams, type OneOfSchema, type AllOfSchema, type ExtendsSchema, type ServiceResolver, type ReturnShape, type ShapeMap, type ShapeJSON, type AIGenerateTextResolver, type AIResolverName, type Resolver, type AgentExecution, type AgentExecutionGenerate, type AgentExecutionChat, type GoogleAuthentication } from '../project-schema';
+import { ArgsType, RefType } from './types';
+import type { ShopifyServiceConfig, RESTServiceConfig, GraphQLServiceConfig, OpenAPIServiceConfig, EncryptedServiceConfig, SchemaWithArgs, SchemaWithRef, ServiceConfigWithOAuth2Authentication, ServiceConfigWithCustomAuthentication, LatestProjectSchemaWithServices, PropertySchemaWithRelationship, CachedShape, MeshShape } from './types';
+/** Resolver Type Utils **/
+/**
+ * Only tests that the shape is right, not that the name is correct. That's a job for the validator.
+ */
+export declare function isBasicResolver(resolver: unknown): resolver is BasicResolver;
+export declare function isServiceResolver(resolver: unknown): resolver is ServiceResolver;
+export declare function isComposeResolver(resolver: unknown): resolver is ComposeResolver;
+export declare function isTakeshapeResolver(resolver: unknown): resolver is TakeshapeResolver;
+export declare function isShapedbResolver(resolver: unknown): resolver is ShapedbResolver;
+export declare function isGraphqlResolver(resolver: unknown): resolver is GraphqlResolver;
+export declare function isRestResolver(resolver: unknown): resolver is RestResolver;
+export declare function isAwsLambdaResolver(resolver: unknown): resolver is AwsLambdaResolver;
+export declare function isUtilResolver(resolver: unknown): resolver is UtilResolver;
+export declare const aiResolverNames: AIResolverName[];
+export declare function isAIResolverName(name: string | undefined): name is AIResolverName;
+export declare function isAIResolver(resolver: unknown): resolver is AIGenerateTextResolver;
+export declare function isAIAgentStateExecution(agentExecution: AgentExecution): agentExecution is AgentExecutionGenerate | AgentExecutionChat;
+export declare function isProjectSchemaWithServices(schema: ProjectSchemaJSON): schema is LatestProjectSchemaWithServices;
+export declare function containsResolver(resolver: Resolver, predicate: (resolver: BasicResolver) => boolean): boolean;
+/** Directive Mapping Utils **/
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveMappingMap
+ */
+export declare function isDirectiveMappingMap(maybeMap: DirectiveMappingMap | DirectiveMappingArray | DirectiveConfig): maybeMap is DirectiveMappingMap;
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveMappingArray
+ */
+export declare function isDirectiveMappingArray(maybeArray: DirectiveMappingMap | DirectiveMappingArray | DirectiveConfig): maybeArray is DirectiveMappingArray;
+/**
+ * Determine whether the ambiguous Directive structure is a DirectiveConfig array
+ */
+export declare function isDirectiveConfig(maybeConfig: DirectiveMappingMap | DirectiveMappingArray | DirectiveConfig): maybeConfig is DirectiveConfig;
+/**
+ * Determine whether a ParameterSerializeOption is a content type serializer
+ */
+export declare function isParameterSerializeContentOptions(maybeContent: ParameterSerializeOptions): maybeContent is ParameterSerializeContentOptions;
+/**
+ * Determine whether an unknown variable is a `ParameterOp`
+ */
+export declare function isParameterOp(maybeOp: unknown): maybeOp is ParameterOp;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpNested`
+ */
+export declare function isParameterOpNested(maybeOp: ParameterOp): maybeOp is ParameterOpNested;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpMapping`
+ */
+export declare function isParameterOpMapping(maybeOp: ParameterOp): maybeOp is ParameterOpMapping;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpValue`
+ */
+export declare function isParameterOpValue(maybeOp: ParameterOp): maybeOp is ParameterOpValue;
+/**
+ * Determine whether a `ParameterOp` is a `ParameterOpOp`
+ */
+export declare function isParameterOpOp(maybeOp: ParameterOp): maybeOp is ParameterOpOp;
+export declare function isParameterSerializeStyleForSearchParams(maybeParam: Maybe<string>): maybeParam is ParameterSerializeStyleOptionsForSearchParams['style'];
+export declare function isParameterSerializeStyleForPathParams(maybeParam: Maybe<string>): maybeParam is ParameterSerializeStyleOptionsForPathParams['style'];
+/**
+ * Determine whether a ParameterSerializeOption is a style serializer
+ */
+export declare function isParameterSerializeStyleOptions(maybeStyle: ParameterSerializeOptions): maybeStyle is ParameterSerializeStyleOptions;
+/** Typeguards for different types of shape schemas **/
+export declare function isRefSchema(propertySchema: PropertySchema): propertySchema is RefSchema | RefSchemaLegacy;
+export declare function isRefSchemaLegacy(propertySchema: PropertySchema): propertySchema is RefSchemaLegacy;
+export declare function isAllOfSchema(propertySchema: PropertySchema): propertySchema is AllOfSchema;
+export declare function isExtendsSchema(propertySchema: unknown): propertySchema is ExtendsSchema;
+export declare function isOneOfSchema(propertySchema: PropertySchema): propertySchema is OneOfSchema;
+export declare function isEnumSchema(obj: PropertySchema): obj is ShapeSchemaEnum;
+export declare function isArraySchema(propertySchema: PropertySchema): propertySchema is ReturnShapeArraySchema;
+export declare function isReturnShapeArraySchema(returnShape: ReturnShape): returnShape is ReturnShapeArraySchema;
+export declare function isObjectSchema(propertySchema: unknown): propertySchema is ObjectSchema;
+/** Service Config Utils **/
+/**
+ * Test all required props, currently:
+ * "name", "slug", "provider", "serviceType", "authenticationType"
+ */
+export declare function isAnyServiceConfig(maybeConfig: any): maybeConfig is AnyServiceConfig;
+export declare function isGraphQLServiceConfig(maybeConfig: any): maybeConfig is GraphQLServiceConfig;
+export declare function isRESTServiceConfig(maybeConfig: any): maybeConfig is RESTServiceConfig;
+export declare function isOpenAPIServiceConfig(maybeConfig: any): maybeConfig is OpenAPIServiceConfig;
+export declare function isShopifyServiceConfig(maybeShopify: AnyServiceConfig): maybeShopify is ShopifyServiceConfig;
+export declare function isEncryptedServiceConfig(maybeConfig: any): maybeConfig is EncryptedServiceConfig;
+export declare function isServiceConfigWithOAuth2Authentication(maybeServiceConfig: any): maybeServiceConfig is ServiceConfigWithOAuth2Authentication;
+export declare function isServiceConfigWithCustomAuthentication(maybeServiceConfig: any): maybeServiceConfig is ServiceConfigWithCustomAuthentication;
+/** Authentication Utils **/
+export declare function isServiceAuthentication(maybeAuthentication: any): maybeAuthentication is ServiceAuthentication;
+export declare function isBearerAuthentication(authentication: ServiceAuthentication): authentication is BearerAuthentication;
+export declare function isBasicAuthentication(authentication: ServiceAuthentication): authentication is BasicAuthentication;
+export declare function isSearchParamsAuthentication(authentication: ServiceAuthentication): authentication is SearchParamsAuthentication;
+export declare function isOAuth2Authentication(authentication: ServiceAuthentication): authentication is OAuth2Authentication;
+export declare function isOAuth2BearerAuthentication(authentication: ServiceAuthentication): authentication is OAuth2BearerAuthentication;
+export declare function isGoogleAuthentication(authentication: ServiceAuthentication): authentication is GoogleAuthentication;
+export declare function isCustomAuthentication(authentication: ServiceAuthentication): authentication is CustomAuthentication;
+/** Miscellaneous Utils **/
+/**
+ * A utility to return the type of args present on a schema.
+ *
+ * @param argsSchema Any schema that may have an `args` property.
+ */
+export declare const getArgsType: (argsSchema: SchemaWithArgs) => Maybe<ArgsType>;
+/**
+ * A utility to return the type of ref present on a schema.
+ *
+ * @param refSchema Any schema that may have a `ref` property.
+ */
+export declare const getRefType: (refSchema: SchemaWithRef) => Maybe<RefType>;
+export declare function isPropertySchemaWithRelationship(schema: PropertySchema): schema is PropertySchemaWithRelationship;
+export declare function isModelShape(shape: ShapeJSON): boolean;
+export declare function isCachedShape(shape: ShapeJSON): shape is CachedShape;
+export declare function listCachedShapes(shapes: ShapeMap): CachedShape[];
+export declare function getCachedShapeMap(shapes: ShapeMap): Record<string, CachedShape>;
+export declare function isMeshShape(shape: ShapeJSON): shape is MeshShape;

package/dist/types/src/unions.d.ts

@@ -0,0 +1,14 @@
+import type { ProjectSchemaJSON, PropertySchema, ObjectSchema, OneOfSchema } from './project-schema';
+import { type PropertyTransform } from './types';
+export type UnionedShape = {
+    propName: string;
+    shapeName: string;
+    shapeId: string;
+    propSchema: PropertySchema;
+};
+export declare function enumerateOneOfKeys(projectSchema: ProjectSchemaJSON, oneOf: PropertySchema[]): UnionedShape[];
+export declare function isUnionSchema(schema: PropertySchema): schema is OneOfSchema;
+export declare function oneOfToObject(projectSchema: ProjectSchemaJSON, schema: PropertySchema): ObjectSchema;
+export type TransformProcessFactory = (projectSchema: ProjectSchemaJSON) => PropertyTransform['process'];
+export declare const createUnwrapTransform: TransformProcessFactory;
+export declare const createWrapTransform: TransformProcessFactory;

package/dist/types/src/user-schema.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 interface User {
+    id: string;
+    email: string;
+    fullName: string;
+    created: number;
+    updated: number;
+    firstTime: boolean;
+    avatarPath?: string;
+    intercomHash?: string;
+    googleUserId?: string;
+    comcastId?: string;
+    token?: string;
+    policies?: AccessPolicyDocument[];
+    preferences?: {
+        [k: string]: any;
+    };
+}
+export interface AccessPolicyDocument {
+    Version: string;
+    Statement: {
+        Effect?: 'Allow' | 'Deny';
+        Sid?: string;
+        Action?: string[];
+        NotAction?: string[];
+        Resource?: string[];
+        NotResource?: string[];
+        Principal?: {
+            AWS?: string[];
+            Service?: string[];
+        };
+        Condition?: {};
+    }[];
+}

package/dist/types/src/util/ai-tools.d.ts

@@ -0,0 +1,3 @@
+import { type AIToolConfig } from '../project-schema/latest';
+export declare function getToolRef(tool: AIToolConfig | string): string;
+export declare function normalizeToolConfig(tool: AIToolConfig | string): AIToolConfig;

package/dist/types/src/util/api-indexing.d.ts

@@ -0,0 +1,9 @@
+import { type Maybe } from '@takeshape/util';
+import type { ShapeLoaders, ProjectSchemaJSON } from '../project-schema';
+import type { GetQueryIndexingConfig, ListQueryIndexingConfig } from '../types';
+export declare function serviceHasIndexedShapes(schema: ProjectSchemaJSON, serviceId: string): boolean;
+export declare function getIndexedServices(projectSchema: ProjectSchemaJSON, configs: ShapeLoaders[keyof ShapeLoaders]): string[];
+type Getter<T> = (context: Pick<ProjectSchemaJSON, 'shapes'>, shapeName: string) => T;
+export declare const getListQueryIndexConfigs: Getter<ListQueryIndexingConfig[]>;
+export declare const getGetQueryIndexConfig: Getter<Maybe<GetQueryIndexingConfig>>;
+export {};

package/dist/types/src/util/detect-cycles.d.ts

@@ -0,0 +1,7 @@
+import { type ProjectSchemaJSON, type PropertySchema } from '../project-schema';
+type SchemaPredicate = (projectSchema: ProjectSchemaJSON, propSchema: PropertySchema, shapeName?: string, propName?: string) => boolean;
+/**
+ * Use a basic depth-first search to determine whether a schema contains a cycle
+ */
+export declare function hasCycle(projectSchema: ProjectSchemaJSON, schema: PropertySchema, predicate?: SchemaPredicate): boolean;
+export {};

package/dist/types/src/util/find-shape-at-path.d.ts

@@ -0,0 +1,21 @@
+import { type ProjectSchemaJSON, type PropertySchema, type ShapeJSON } from '../project-schema';
+/**
+ *
+ * @param projectSchema
+ * @param schema
+ * @param queryPath
+ *
+ * @example
+ * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
+ */
+export declare function findSchemaAtPath(projectSchema: ProjectSchemaJSON, schema: PropertySchema, queryPath: string[]): PropertySchema | undefined;
+/**
+ *
+ * @param projectSchema
+ * @param propSchema
+ * @param queryPath
+ *
+ * @example
+ * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
+ */
+export declare function findShapeAtPath(projectSchema: ProjectSchemaJSON, propSchema: PropertySchema, queryPath: string[]): ShapeJSON | undefined;

package/dist/types/src/util/form-config.d.ts

@@ -0,0 +1,11 @@
+import { type Maybe } from '@takeshape/util';
+import { type FormConfig, type FormMap, type ProjectSchemaJSON } from '../project-schema';
+/**
+ * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
+ * The original forms are left intact.
+ */
+export declare function normalizeForms(projectSchema: ProjectSchemaJSON): FormMap;
+/**
+ * Find the form config for a given shape name and the form key.
+ */
+export declare function findShapeFormConfig(projectSchema: ProjectSchemaJSON, shapeName: string, formName: string): Maybe<FormConfig>;

package/dist/types/src/util/get-conflicting-properties.d.ts

@@ -0,0 +1,6 @@
+import { type ShapeJSON } from '../project-schema';
+import { type ServicesShapesContext } from '../refs';
+/**
+ * Given a list of shapes find the conflicting props
+ */
+export declare function getConflictingProperties(context: ServicesShapesContext, shapes: ShapeJSON[]): Set<string>;

package/dist/types/src/util/get-return-shape.d.ts

@@ -0,0 +1,4 @@
+import { type ProjectSchemaJSON, type PropertySchema, type QueryJSON, type ShapeJSON } from '../project-schema';
+import { type ServicesShapesContext } from '../refs';
+export declare function getReturnShapeRef(context: ServicesShapesContext, propOrQuery: PropertySchema | QueryJSON): import("@takeshape/util").Maybe<import("../refs").RefItem>;
+export declare function getReturnShape(projectSchema: ProjectSchemaJSON, propOrQuery: PropertySchema | QueryJSON): ShapeJSON | undefined;

package/dist/types/src/util/has-arg.d.ts

@@ -0,0 +1,4 @@
+import { type Args, type ProjectSchemaJSON } from '../project-schema';
+import { type SchemaWithArgs } from '../types';
+export declare function getArgs(prop: SchemaWithArgs): Args | undefined;
+export declare function hasArg(projectSchema: ProjectSchemaJSON, prop: SchemaWithArgs, argPath: string | string[]): boolean;

package/dist/types/src/util/merge.d.ts

@@ -0,0 +1,15 @@
+import { type FormConfig, type ObjectSchema, type ProjectSchemaJSON } from '../project-schema';
+export declare function mergeObjectSchemas(...args: Array<ObjectSchema | undefined>): ObjectSchema;
+export declare function mergeDeepObjectSchemas(...args: Array<ObjectSchema | undefined>): ObjectSchema;
+export declare function mergeSchemaProperties(parent: ObjectSchema, overrides: ObjectSchema, deep?: boolean): ObjectSchema;
+export declare function rebaseSchemaProperties(base: ObjectSchema, parent: ObjectSchema, head: ObjectSchema): ObjectSchema;
+export declare function mergeFormProperties(parent: FormConfig, overrides: FormConfig): FormConfig;
+export declare function rebaseFormProperties(base: FormConfig, parent: FormConfig, head: FormConfig): FormConfig;
+export declare function mergeFormConfigs(...configs: FormConfig[]): FormConfig;
+export declare function mergeProjectSchemas(base: ProjectSchemaJSON, parent: ProjectSchemaJSON, head: ProjectSchemaJSON): {
+    error: string;
+    mergedSchema: undefined;
+} | {
+    error: undefined;
+    mergedSchema: ProjectSchemaJSON;
+};

package/dist/types/src/util/patch-schema.d.ts

@@ -0,0 +1,8 @@
+import { type ProjectSchemaJSON } from '../project-schema';
+import { type ProjectSchemaUpdate } from '../migration/types';
+export declare function shallowMerge<T>(original: Record<string, T> | undefined, update: Record<string, T | null> | undefined): Record<string, T>;
+/**
+ * Apply a schema update to a schema.
+ * Resulting schema is not assumed to be valid and should be validated if appropriate.
+ */
+export declare function patchSchema<T extends ProjectSchemaJSON>(projectSchema: T, update: ProjectSchemaUpdate): T;

package/dist/types/src/util/shapes.d.ts

@@ -0,0 +1,5 @@
+import { type ShapeJSON, type ProjectSchemaJSON } from '../project-schema';
+export declare function getShapeById(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, shapeId: string): ShapeJSON | undefined;
+export declare function getShape(context: Pick<ProjectSchemaJSON, 'shapes'>, name: string): ShapeJSON | undefined;
+export declare function ensureShape(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, name: string): ShapeJSON;
+export declare function ensureShapeById(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, shapeId: string): ShapeJSON;

package/dist/types/src/validate.d.ts

@@ -0,0 +1,70 @@
+import type { ErrorObject } from 'ajv';
+import { type SchemaValidationErrorItem } from '@takeshape/errors';
+import { type Entitlements } from '@takeshape/util';
+import { type SetRequired } from 'type-fest';
+import type { AnyProjectSchemaJSON, ProjectSchemaJSON } from './project-schema';
+import type { ProjectSchemaImport, LayerState } from './types/types';
+import type { RoleImport, RoleInput } from './auth-schemas';
+export declare const builtInShapeNames: Set<string>;
+export type SchemaValidationResult = {
+    valid: true;
+    schema: AnyProjectSchemaJSON;
+    errors: undefined;
+} | {
+    valid: false;
+    schema: undefined;
+    errors: SchemaValidationErrorItem[];
+};
+export declare function formatError(error: ErrorObject): SchemaValidationErrorItem;
+export type Validation = {
+    version: string;
+    schemaId: string;
+    isVersion: (schemaVersion?: string) => boolean;
+    validate: (schema: unknown, options?: ValidateSyntaxOptions) => SchemaValidationResult;
+};
+export type ValidateSyntaxOptions = {
+    suppressErrorPaths?: string[];
+    resolveLayer?: ResolveLayer;
+};
+export type ResolveLayer = (layerId: string) => Promise<LayerState>;
+export type ValidateContext = {
+    resolveLayer?: ResolveLayer;
+    allowDisconnectedLayers?: boolean;
+    entitlements: Entitlements;
+} & ValidateSyntaxOptions;
+export type ValidateReferencesContext = SetRequired<ValidateContext, 'resolveLayer'>;
+export declare function validateSchemaSyntax(obj: unknown, options?: ValidateSyntaxOptions): SchemaValidationResult;
+/**
+ * Validates a schema using a matching validation based on the `schemaVersion` property.
+ */
+export declare function validateSchema(context: ValidateContext, obj: unknown): Promise<SchemaValidationResult>;
+export declare function ensureValidLatestSchemaSyntax(obj: unknown): ProjectSchemaJSON;
+/**
+ * Validates and returns a `RoleInput`, which is a subset of the `Role`
+ * type's properties suitable for importing.
+ */
+export declare function validateRoleInput(maybeRoleInput: unknown): RoleInput;
+/**
+ * Validates and returns a `RoleImport` array, which is a collection of `RoleInput`s.
+ */
+export declare function ensureValidRoleImport(maybeRoles: unknown): RoleImport;
+export type ProjectSchemaImportValidationResult = {
+    valid: true;
+    schema: ProjectSchemaImport;
+    errors: undefined;
+} | {
+    valid: false;
+    schema: undefined;
+    errors: SchemaValidationErrorItem[];
+};
+/**
+ * Only use when validating an imported schema! ignore fields optional when importing
+ */
+export declare function validateProjectSchemaImport(maybeSchema: unknown): ProjectSchemaImportValidationResult;
+/**
+ * Only use when validating an imported schema!
+ *
+ * New style validation for parity with the `validateRoleImport` fn. Returns
+ * a valid, clean `ImportProjectSchema` or throws a `SchemaValidationError`.
+ */
+export declare function ensureValidProjectSchemaImport(maybeSchema: unknown): ProjectSchemaImport;

package/dist/types/src/versions.d.ts

@@ -0,0 +1,4 @@
+export { CURRENT_SCHEMA_VERSION } from './schemas';
+export declare const LEGACY_SCHEMA_VERSION = "1.0.0";
+export declare const CURRENT_API_VERSION = "2";
+export declare const LEGACY_API_VERSION = "1";