## API Report File for "@aws-amplify/graphql-transformer-core"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { AmplifyDynamoDbModelDataSourceStrategy } from '@aws-amplify/graphql-transformer-interfaces';
import { ApiKeyConfig } from 'aws-cdk-lib/aws-appsync';
import { AppSyncAuthConfiguration } from '@aws-amplify/graphql-transformer-interfaces';
import { AppSyncDataSourceType } from '@aws-amplify/graphql-transformer-interfaces';
import { AppSyncFunctionConfigurationProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { AssetProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { AuthorizationConfig } from 'aws-cdk-lib/aws-appsync';
import { AuthorizationType } from 'aws-cdk-lib/aws-appsync';
import { CfnApiKey } from 'aws-cdk-lib/aws-appsync';
import { CfnFunctionConfiguration } from 'aws-cdk-lib/aws-appsync';
import { CfnGraphQLSchema } from 'aws-cdk-lib/aws-appsync';
import { CfnParameter } from 'aws-cdk-lib';
import { CfnResource } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { DataSourceInstance } from '@aws-amplify/graphql-transformer-interfaces';
import { DataSourceProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { DataSourceStrategiesProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { DefaultDynamoDbModelDataSourceStrategy } from '@aws-amplify/graphql-transformer-interfaces';
import { DefinitionNode } from 'graphql';
import { DirectiveDefinitionNode } from 'graphql';
import { DirectiveNode } from 'graphql';
import { DocumentNode } from 'graphql/language';
import { DocumentNode as DocumentNode_2 } from 'graphql';
import { EnumTypeDefinitionNode } from 'graphql';
import { EnumTypeExtensionNode } from 'graphql';
import { Expression } from 'graphql-mapping-template';
import { FieldDefinitionNode } from 'graphql';
import { FieldNode } from 'graphql';
import { FunctionRuntimeTemplate } from '@aws-amplify/graphql-transformer-interfaces';
import { Grant } from 'aws-cdk-lib/aws-iam';
import { GraphqlApiBase } from 'aws-cdk-lib/aws-appsync';
import { GraphQLAPIProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { GraphQLError } from 'graphql';
import * as iam from 'aws-cdk-lib/aws-iam';
import { IamResource } from 'aws-cdk-lib/aws-appsync';
import { IGrantable } from 'aws-cdk-lib/aws-iam';
import { ImportedAmplifyDynamoDbModelDataSourceStrategy } from '@aws-amplify/graphql-transformer-interfaces';
import { InlineMappingTemplateProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { InputObjectTypeDefinitionNode } from 'graphql';
import { InputObjectTypeExtensionNode } from 'graphql';
import { InputValueDefinitionNode } from 'graphql';
import { InterfaceTypeDefinitionNode } from 'graphql';
import { InterfaceTypeExtensionNode } from 'graphql';
import { JSRuntimeTemplate } from '@aws-amplify/graphql-transformer-interfaces';
import { Location as Location_2 } from 'graphql';
import { LogConfig } from '@aws-amplify/graphql-transformer-interfaces';
import { MappingTemplateProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { ModelDataSourceStrategy } from '@aws-amplify/graphql-transformer-interfaces';
import { ModelDataSourceStrategyDbType } from '@aws-amplify/graphql-transformer-interfaces';
import { ModelDataSourceStrategySqlDbType } from '@aws-amplify/graphql-transformer-interfaces';
import { ModelFieldMap } from '@aws-amplify/graphql-transformer-interfaces';
import { MutationFieldType } from '@aws-amplify/graphql-transformer-interfaces';
import { NamedTypeNode } from 'graphql';
import { NestedStackProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { ObjectTypeDefinitionNode } from 'graphql';
import { ObjectTypeExtensionNode } from 'graphql';
import { OperationTypeDefinitionNode } from 'graphql';
import { QueryFieldType } from '@aws-amplify/graphql-transformer-interfaces';
import { RDSLayerMapping } from '@aws-amplify/graphql-transformer-interfaces';
import { RDSLayerMappingProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { RDSSNSTopicMapping } from '@aws-amplify/graphql-transformer-interfaces';
import { RDSSNSTopicMappingProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { S3Asset } from '@aws-amplify/graphql-transformer-interfaces';
import { S3MappingTemplateProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { SchemaDefinitionNode } from 'graphql';
import { SqlDirectiveDataSourceStrategy } from '@aws-amplify/graphql-transformer-interfaces';
import { SQLLambdaModelDataSourceStrategy } from '@aws-amplify/graphql-transformer-interfaces';
import { Stack } from 'aws-cdk-lib';
import { StackManagerProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { StringValueNode } from 'graphql';
import { SubscriptionFieldType } from '@aws-amplify/graphql-transformer-interfaces';
import { SynthParameters } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerAuthProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerContextMetadataProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerContextOutputProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerContextProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerDataSourceManagerProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerLog } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerModelEnhancementProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerModelProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerPluginProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerPluginType } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerProviderRegistry } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerResolverProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerResolversManagerProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerResourceHelperProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerSchemaVisitStepContextProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerSecrets } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformerTransformSchemaStepContextProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformHostProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformParameterProvider } from '@aws-amplify/graphql-transformer-interfaces';
import { TransformParameters } from '@aws-amplify/graphql-transformer-interfaces';
import { TypeDefinitionNode } from 'graphql';
import { TypeNode } from 'graphql';
import { TypeSystemDefinitionNode } from 'graphql';
import { UnionTypeDefinitionNode } from 'graphql';
import { UnionTypeExtensionNode } from 'graphql';
import { Visibility } from 'aws-cdk-lib/aws-appsync';
import { VTLRuntimeTemplate } from '@aws-amplify/graphql-transformer-interfaces';

// @public (undocumented)
export const APICategory = "api";

// @public (undocumented)
export const APPSYNC_JS_RUNTIME: CfnFunctionConfiguration.AppSyncRuntimeProperty;

// @public (undocumented)
export function collectDirectives(sdl: string): DirectiveNode[];

// @public (undocumented)
export function collectDirectivesByTypeNames(sdl: string): {
    types: Record<string, string[]>;
    directives: string[];
};

// @public (undocumented)
export type ConflictDetectionType = 'VERSION' | 'NONE';

// @public (undocumented)
export const enum ConflictHandlerType {
    // (undocumented)
    AUTOMERGE = "AUTOMERGE",
    // (undocumented)
    LAMBDA = "LAMBDA",
    // (undocumented)
    OPTIMISTIC = "OPTIMISTIC_CONCURRENCY"
}

// @public (undocumented)
export const constructArrayFieldsStatement: (tableName: string, ctx: TransformerContextProvider) => Expression;

// @public (undocumented)
export const constructAuthFilterStatement: (keyName: string, emptyAuthFilter?: boolean) => Expression;

// @public (undocumented)
export const constructDataSourceStrategies: (schema: string, dataSourceStrategy: ModelDataSourceStrategy) => Record<string, ModelDataSourceStrategy>;

// @public (undocumented)
export const constructFieldMappingInput: () => Expression;

// @public (undocumented)
export const constructNonScalarFieldsStatement: (tableName: string, ctx: TransformerContextProvider) => Expression;

// @public (undocumented)
export const constructSqlDirectiveDataSourceStrategies: (schema: string, dataSourceStrategy: ModelDataSourceStrategy, customSqlStatements?: Record<string, string>) => SqlDirectiveDataSourceStrategy[];

// @public (undocumented)
export const convertNamedTypeToJSONSchema: (namedType: NamedTypeNode) => JSONSchema;

// @public (undocumented)
function createSyncLambdaIAMPolicy(context: TransformerContextProvider, scope: Construct, name: string, region?: string): iam.Policy;

// Warning: (ae-forgotten-export) The symbol "TransformerContext" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
function createSyncTable(context: TransformerContext): void;

// @public (undocumented)
export const DDB_AMPLIFY_MANAGED_DATASOURCE_STRATEGY: ModelDataSourceStrategy;

// @public (undocumented)
export const DDB_DB_TYPE: ModelDataSourceStrategyDbType;

// @public (undocumented)
export const DDB_DEFAULT_DATASOURCE_STRATEGY: ModelDataSourceStrategy;

// @public (undocumented)
export class DirectiveWrapper {
    constructor(node: DirectiveNode);
    // (undocumented)
    getArguments: <T>(defaultValue: Required<T>, options?: GetArgumentsOptions) => Required<T>;
    // (undocumented)
    serialize: () => DirectiveNode;
}

// @public (undocumented)
export class EnumWrapper {
    constructor(node: EnumTypeDefinitionNode);
    // (undocumented)
    addValue: (value: string) => void;
    // (undocumented)
    static create: (name: string, values?: string[]) => EnumWrapper;
    // (undocumented)
    directives: DirectiveWrapper[];
    // (undocumented)
    readonly name: string;
    // (undocumented)
    serialize: () => EnumTypeDefinitionNode;
    // (undocumented)
    values: string[];
}

// @public (undocumented)
export const fieldsWithSqlDirective: (obj: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode | ObjectTypeExtensionNode) => FieldDefinitionNode[];

// Warning: (ae-forgotten-export) The symbol "GenericFieldWrapper" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export class FieldWrapper extends GenericFieldWrapper {
    constructor(field: FieldDefinitionNode);
    // (undocumented)
    readonly argumenets?: InputValueDefinitionNode[];
    // (undocumented)
    static create: (name: string, type: string, isNullable?: boolean, isList?: boolean) => FieldWrapper;
    // (undocumented)
    readonly description?: StringValueNode;
    // (undocumented)
    readonly loc?: Location_2;
    // (undocumented)
    serialize: () => FieldDefinitionNode;
}

// @public (undocumented)
export const generateGetArgumentsInput: ({ shouldDeepMergeDirectiveConfigDefaults }: TransformParameters) => GetArgumentsOptions;

// @public (undocumented)
export const getAppSyncServiceExtraDirectives: () => string;

// @public (undocumented)
export type GetArgumentsOptions = {
    deepMergeArguments?: boolean;
};

// @public (undocumented)
export const getArrayFields: (object: ObjectTypeDefinitionNode | undefined, ctx: TransformerContextProvider) => string[];

// @public (undocumented)
export const getConditionInputName: (modelName: string) => string;

// @public (undocumented)
export const getConnectionName: (modelName: string) => string;

// @public (undocumented)
export const getDefaultStrategyNameForDbType: (dbType: ModelDataSourceStrategySqlDbType) => string;

// @public (undocumented)
export const getField: (obj: ObjectTypeDefinitionNode, fieldName: string) => FieldDefinitionNode | undefined;

// Warning: (ae-forgotten-export) The symbol "Operation" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export const getFieldNameFor: (op: Operation, typeName: string) => string;

// @public (undocumented)
export const getFilterInputName: (modelName: string) => string;

// @public (undocumented)
export const getImportedRDSTypeFromStrategyDbType: (dbType: ModelDataSourceStrategyDbType) => ImportedRDSType;

// @public (undocumented)
export const getKeySchema: (table: any, indexName?: string) => any;

// @public (undocumented)
export const getModelDataSourceNameForTypeName: (ctx: DataSourceStrategiesProvider, typeName: string) => string;

// @public (undocumented)
export const getModelDataSourceStrategy: (ctx: DataSourceStrategiesProvider, typename: string) => ModelDataSourceStrategy;

// @public (undocumented)
export const getModelTypeNames: (schema: string) => string[];

// @public (undocumented)
export const getNonScalarFields: (object: ObjectTypeDefinitionNode | undefined, ctx: TransformerContextProvider) => string[];

// @public (undocumented)
export const getParameterStoreSecretPath: (secret: string, secretsKey: string, apiName: string, environmentName: string, appId: string) => string;

// @public (undocumented)
export const getPrimaryKeyFieldNodes: (type: ObjectTypeDefinitionNode) => FieldDefinitionNode[];

// @public (undocumented)
export const getPrimaryKeyFields: (type: ObjectTypeDefinitionNode) => string[];

// @public (undocumented)
export const getResourceName: (scope: Construct) => string | undefined;

// @public (undocumented)
export const getResourceNamesForStrategy: (strategy: SQLLambdaModelDataSourceStrategy) => SQLLambdaResourceNames;

// @public (undocumented)
export const getResourceNamesForStrategyName: (strategyName: string) => SQLLambdaResourceNames;

// @public (undocumented)
export const getSortKeyFieldNames: (type: ObjectTypeDefinitionNode) => string[];

// @public (undocumented)
export const getStrategyDbTypeFromModel: (ctx: DataSourceStrategiesProvider, typename: string) => ModelDataSourceStrategyDbType;

// @public (undocumented)
export const getStrategyDbTypeFromTypeNode: (type: TypeNode, ctx: TransformerContextProvider) => ModelDataSourceStrategyDbType;

// @public (undocumented)
export const getSubscriptionFilterInputName: (modelName: string) => string;

// @public (undocumented)
function getSyncConfig(ctx: TransformerTransformSchemaStepContextProvider, typeName: string): SyncConfig | undefined;

// @public (undocumented)
export const getTable: (ctx: TransformerContextProvider, object: ObjectTypeDefinitionNode) => any;

// @public (undocumented)
export const getType: (schema: DocumentNode_2, typeName: string) => ObjectTypeDefinitionNode | undefined;

// @public (undocumented)
export const GraphQLScalarJSONSchemaDefinition: {
    Boolean: JSONSchema;
    Int: JSONSchema;
    Float: JSONSchema;
    String: JSONSchema;
    AWSDateTime: JSONSchema;
    ID: JSONSchema;
    AWSJSON: JSONSchema;
    AWSEmail: JSONSchema;
    AWSDate: JSONSchema;
    AWSTime: JSONSchema;
    AWSTimestamp: JSONSchema;
    AWSPhone: JSONSchema;
    AWSURL: JSONSchema;
    AWSIPAddress: JSONSchema;
};

// @public (undocumented)
export class GraphQLTransform {
    constructor(options: GraphQLTransformOptions);
    // Warning: (ae-forgotten-export) The symbol "TransformerOutput" needs to be exported by the entry point index.d.ts
    // Warning: (ae-forgotten-export) The symbol "GraphQLApi" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    protected generateGraphQlApi(stackManager: StackManagerProvider, assetProvider: AssetProvider, synthParameters: SynthParameters, output: TransformerOutput, transformParameters: TransformParameters, logging?: true | LogConfig): GraphQLApi;
    // (undocumented)
    getLogs(): TransformerLog[];
    // (undocumented)
    preProcessSchema(schema: DocumentNode): DocumentNode;
    // Warning: (ae-forgotten-export) The symbol "TransformOption" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    transform({ assetProvider, dataSourceStrategies, nestedStackProvider, parameterProvider, rdsLayerMapping, rdsSnsTopicMapping, schema, scope, sqlDirectiveDataSourceStrategies, synthParameters, logging, }: TransformOption): void;
}

// @public (undocumented)
export interface GraphQLTransformOptions {
    // (undocumented)
    readonly authConfig?: AppSyncAuthConfiguration;
    // (undocumented)
    readonly host?: TransformHostProvider;
    // (undocumented)
    readonly resolverConfig?: ResolverConfig;
    // Warning: (ae-forgotten-export) The symbol "StackMapping" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    readonly stackMapping?: StackMapping;
    // (undocumented)
    readonly transformers: TransformerPluginProvider[];
    // (undocumented)
    readonly transformParameters?: Partial<TransformParameters>;
    // (undocumented)
    readonly userDefinedSlots?: Record<string, UserDefinedSlot[]>;
}

// @public (undocumented)
export type ImportAppSyncAPIInputs = {
    apiName: string;
    dataSourceConfig?: ImportedDataSourceConfig;
};

// @public (undocumented)
export type ImportedDataSourceConfig = RDSDataSourceConfig;

// @public (undocumented)
export type ImportedDataSourceType = ImportedRDSType;

// @public (undocumented)
export enum ImportedRDSType {
    // (undocumented)
    MYSQL = "mysql",
    // (undocumented)
    POSTGRESQL = "postgres"
}

// @public (undocumented)
export class InputFieldWrapper extends GenericFieldWrapper {
    constructor(field: InputValueDefinitionNode);
    // (undocumented)
    readonly argumenets?: InputValueDefinitionNode[];
    // (undocumented)
    static create: (name: string, type: string, isNullable?: boolean, isList?: boolean) => InputFieldWrapper;
    // (undocumented)
    readonly description?: StringValueNode;
    // (undocumented)
    protected field: InputValueDefinitionNode;
    // (undocumented)
    static fromField: (name: string, field: FieldDefinitionNode, parent: ObjectTypeDefinitionNode, document: DocumentNode_2) => InputFieldWrapper;
    // (undocumented)
    readonly loc?: Location_2;
    // (undocumented)
    readonly name: string;
    // (undocumented)
    serialize: () => InputValueDefinitionNode;
    // (undocumented)
    type: TypeNode;
}

// @public (undocumented)
export class InputObjectDefinitionWrapper {
    constructor(node: InputObjectTypeDefinitionNode);
    // (undocumented)
    addField: (field: InputFieldWrapper) => void;
    // (undocumented)
    static create: (name: string, fields?: InputValueDefinitionNode[], directives?: DirectiveNode[]) => InputObjectDefinitionWrapper;
    // (undocumented)
    readonly directives?: DirectiveWrapper[];
    // (undocumented)
    readonly fields: InputFieldWrapper[];
    // (undocumented)
    static fromObject: (name: string, def: ObjectTypeDefinitionNode, document: DocumentNode_2) => InputObjectDefinitionWrapper;
    // (undocumented)
    getField: (name: string) => InputFieldWrapper;
    // (undocumented)
    hasField: (name: string) => boolean;
    // (undocumented)
    readonly name: string;
    // (undocumented)
    removeField: (field: InputFieldWrapper) => void;
    // (undocumented)
    serialize: () => InputObjectTypeDefinitionNode;
}

// @public (undocumented)
export class InvalidDirectiveError extends Error {
    constructor(message: string);
}

// @public (undocumented)
export class InvalidMigrationError extends Error {
    constructor(message: string, causedBy: string, fix: string);
    // (undocumented)
    causedBy: string;
    // (undocumented)
    fix: string;
}

// @public (undocumented)
export class InvalidTransformerError extends Error {
    constructor(message: string);
}

// @public (undocumented)
export const isAmplifyDynamoDbModelDataSourceStrategy: (strategy: ModelDataSourceStrategy) => strategy is AmplifyDynamoDbModelDataSourceStrategy;

// @public (undocumented)
export const isBuiltInGraphqlNode: (obj: DefinitionNode) => obj is (ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode) & {
    name: {
        value: 'Mutation' | 'Query' | 'Subscription';
    };
};

// @public (undocumented)
export const isDefaultDynamoDbModelDataSourceStrategy: (strategy: ModelDataSourceStrategy) => strategy is DefaultDynamoDbModelDataSourceStrategy;

// @public (undocumented)
export const isDisallowedScalarType: (type: string) => boolean;

// @public (undocumented)
export const isDynamoDbModel: (ctx: DataSourceStrategiesProvider, typename: string) => boolean;

// @public (undocumented)
export const isDynamoDbType: (dbType: ModelDataSourceStrategyDbType) => dbType is "DYNAMODB";

// @public (undocumented)
export const isImportedAmplifyDynamoDbModelDataSourceStrategy: (strategy: ModelDataSourceStrategy) => strategy is ImportedAmplifyDynamoDbModelDataSourceStrategy;

// @public (undocumented)
function isLambdaSyncConfig(syncConfig: SyncConfig): syncConfig is SyncConfigLambda;

// @public (undocumented)
export const isModelType: (ctx: DataSourceStrategiesProvider, typename: string) => boolean;

// @public (undocumented)
export const isMutationNode: (obj: DefinitionNode) => obj is (ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode) & {
    name: {
        value: 'Mutation';
    };
};

// @public (undocumented)
export const isObjectTypeDefinitionNode: (obj: DefinitionNode) => obj is ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;

// @public (undocumented)
export const isPostgresDbType: (dbType: ModelDataSourceStrategyDbType) => dbType is "POSTGRES";

// @public (undocumented)
export const isPostgresModel: (ctx: DataSourceStrategiesProvider, typename: string) => boolean;

// @public (undocumented)
export const isQueryNode: (obj: DefinitionNode) => obj is (ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode) & {
    name: {
        value: 'Query';
    };
};

// @public (undocumented)
export const isQueryType: (typeName: string) => typeName is "Query";

// @public (undocumented)
export const isSqlDbType: (dbType: ModelDataSourceStrategyDbType) => dbType is ModelDataSourceStrategySqlDbType;

// @public (undocumented)
export const isSqlModel: (ctx: DataSourceStrategiesProvider, typename: string) => boolean;

// @public (undocumented)
export const isSqlStrategy: (strategy: ModelDataSourceStrategy) => strategy is SQLLambdaModelDataSourceStrategy;

// @public (undocumented)
export type JSONSchema = {
    type: string;
    properties?: Record<string, JSONSchema>;
    required?: string[];
    items?: JSONSchema;
    enum?: (string | number | boolean | null)[];
    minimum?: number;
    maximum?: number;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    format?: string;
    description?: string;
    default?: JSONLike;
    additionalProperties?: boolean | JSONSchema;
};

// @public (undocumented)
export class MappingTemplate {
    // Warning: (ae-forgotten-export) The symbol "InlineTemplate" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    static inlineTemplateFromString(template: string): InlineTemplate;
    // Warning: (ae-forgotten-export) The symbol "S3MappingJSResolverFunctionCode" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    static s3MappingFunctionCodeFromString(template: string, templateName: string): S3MappingJSResolverFunctionCode;
    // Warning: (ae-forgotten-export) The symbol "S3MappingTemplate" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    static s3MappingTemplateFromString(template: string, templateName: string): S3MappingTemplate;
}

// @public (undocumented)
export const MYSQL_DB_TYPE: ModelDataSourceStrategySqlDbType;

// @public (undocumented)
export const normalizeDbType: (candidate: string) => ModelDataSourceStrategyDbType;

// @public (undocumented)
export class ObjectDefinitionWrapper {
    constructor(node: ObjectTypeDefinitionNode);
    // (undocumented)
    addField: (field: FieldWrapper) => void;
    // (undocumented)
    static create: (name: string, fields?: FieldDefinitionNode[], directives?: DirectiveNode[]) => ObjectDefinitionWrapper;
    // (undocumented)
    readonly directives?: DirectiveWrapper[];
    // (undocumented)
    readonly fields: FieldWrapper[];
    // (undocumented)
    getField: (name: string) => FieldWrapper;
    // (undocumented)
    hasField: (name: string) => boolean;
    // (undocumented)
    readonly name: string;
    // (undocumented)
    removeField: (field: FieldWrapper) => void;
    // (undocumented)
    serialize: () => ObjectTypeDefinitionNode;
}

// @public (undocumented)
export const POSTGRES_DB_TYPE: ModelDataSourceStrategySqlDbType;

// @public (undocumented)
export type RDSConnectionSecrets = TransformerSecrets & {
    username: string;
    password: string;
    host: string;
    database: string;
    port: number;
};

// @public (undocumented)
export type RDSDataSourceConfig = RDSConnectionSecrets & {
    engine: ImportedRDSType;
};

// @public (undocumented)
export type ResolverConfig = {
    project?: SyncConfig;
    models?: Record<string, SyncConfig>;
};

// @public (undocumented)
export class SchemaValidationError extends Error {
    constructor(errors: Readonly<GraphQLError[]>);
}

// @public (undocumented)
export const setResourceName: (scope: Construct, { name, setOnDefaultChild }: SetResourceNameProps) => void;

// @public (undocumented)
export type SetResourceNameProps = {
    name: string;
    setOnDefaultChild?: boolean;
};

// @public (undocumented)
export const SQL_SCHEMA_FILE_NAME = "schema.sql.graphql";

// @public (undocumented)
export interface SQLLambdaResourceNames {
    // (undocumented)
    sqlLambdaAliasLogicalId: string;
    // (undocumented)
    sqlLambdaAliasName: string;
    // (undocumented)
    sqlLambdaDataSource: string;
    // (undocumented)
    sqlLambdaExecutionRole: string;
    // (undocumented)
    sqlLambdaExecutionRolePolicy: string;
    // (undocumented)
    sqlLambdaFunction: string;
    // (undocumented)
    sqlLambdaLayerVersion: string;
    // (undocumented)
    sqlLayerVersionMapping: string;
    // (undocumented)
    sqlLayerVersionResolverCustomResource: string;
    // (undocumented)
    sqlPatchingLambdaExecutionRole: string;
    // (undocumented)
    sqlPatchingLambdaExecutionRolePolicy: string;
    // (undocumented)
    sqlPatchingLambdaFunction: string;
    // (undocumented)
    sqlPatchingSubscription: string;
    // (undocumented)
    sqlPatchingTopic: string;
    // (undocumented)
    sqlSNSTopicArnMapping: string;
    // (undocumented)
    sqlSNSTopicARNResolverCustomResource: string;
    // (undocumented)
    sqlStack: string;
    // (undocumented)
    sqlVpcEndpointPrefix: string;
}

// @public (undocumented)
export class StackManager implements StackManagerProvider {
    // Warning: (ae-forgotten-export) The symbol "ResourceToStackMap" needs to be exported by the entry point index.d.ts
    constructor(scope: Construct, nestedStackProvider: NestedStackProvider, parameterProvider: TransformParameterProvider | undefined, resourceMapping: ResourceToStackMap);
    // (undocumented)
    createStack: (stackName: string) => Stack;
    // (undocumented)
    getParameter: (name: string) => CfnParameter | void;
    // (undocumented)
    getScopeFor: (resourceId: string, defaultStackName?: string) => Construct;
    // (undocumented)
    getStack: (stackName: string) => Stack;
    // (undocumented)
    getStackFor: (resourceId: string, defaultStackName?: string) => Construct;
    // (undocumented)
    hasStack: (stackName: string) => boolean;
    // (undocumented)
    readonly scope: Construct;
}

// @public (undocumented)
export const supportedScalarTypes: string[];

// @public (undocumented)
export type SyncConfig = SyncConfigOptimistic | SyncConfigServer | SyncConfigLambda;

// @public (undocumented)
export type SyncConfigLambda = {
    ConflictDetection: ConflictDetectionType;
    ConflictHandler: ConflictHandlerType.LAMBDA;
    LambdaConflictHandler: LambdaConflictHandler;
};

// @public (undocumented)
export type SyncConfigOptimistic = {
    ConflictDetection: ConflictDetectionType;
    ConflictHandler: ConflictHandlerType.OPTIMISTIC;
};

// @public (undocumented)
export type SyncConfigServer = {
    ConflictDetection: ConflictDetectionType;
    ConflictHandler: ConflictHandlerType.AUTOMERGE;
};

// Warning: (ae-forgotten-export) The symbol "DeltaSyncConfig" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
function syncDataSourceConfig(): DeltaSyncConfig;

declare namespace SyncUtils {
    export {
        createSyncTable,
        syncDataSourceConfig,
        validateResolverConfigForType,
        getSyncConfig,
        isLambdaSyncConfig,
        createSyncLambdaIAMPolicy
    }
}
export { SyncUtils }

// @public (undocumented)
export interface TransformConfig {
    // (undocumented)
    DisableResolverDeduping?: boolean;
    // (undocumented)
    NodeToNodeEncryption?: boolean;
    // (undocumented)
    StackMapping?: {
        [resourceId: string]: string;
    };
    // (undocumented)
    TransformerOptions?: {
        [transformer: string]: {
            [option: string]: any;
        };
    };
    // (undocumented)
    transformers?: string[];
}

// @public (undocumented)
export abstract class TransformerAuthBase extends TransformerPluginBase implements TransformerAuthProvider {
    constructor(name: string, doc: DocumentNode_2 | string, type?: TransformerPluginType);
}

// @public (undocumented)
export class TransformerContractError extends Error {
    constructor(message: string);
}

// @public (undocumented)
export abstract class TransformerModelBase extends TransformerPluginBase implements TransformerModelProvider {
    constructor(name: string, document: DocumentNode_2 | string, type?: TransformerPluginType);
    // (undocumented)
    abstract generateCreateResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract generateDeleteResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract generateGetResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract generateListResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract generateOnCreateResolver?: (ctx: TransformerContextProvider, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract generateOnDeleteResolver?: (ctx: TransformerContextProvider, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract generateOnUpdateResolver?: (ctx: TransformerContextProvider, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract generateSyncResolver?: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract generateUpdateResolver: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, typeName: string, fieldName: string, resolverLogicalId: string, directive?: DirectiveDefinitionNode) => TransformerResolverProvider;
    // (undocumented)
    abstract getDataSourceResource: (type: ObjectTypeDefinitionNode) => DataSourceInstance;
    // (undocumented)
    abstract getDataSourceType: () => AppSyncDataSourceType;
    // (undocumented)
    abstract getInputs: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, operation: {
        fieldName: string;
        typeName: string;
        type: QueryFieldType | MutationFieldType | SubscriptionFieldType;
    }) => InputValueDefinitionNode[];
    // (undocumented)
    abstract getMutationFieldNames: (type: ObjectTypeDefinitionNode, directive?: DirectiveDefinitionNode) => Set<{
        fieldName: string;
        typeName: string;
        type: MutationFieldType;
    }>;
    // (undocumented)
    abstract getOutputType: (ctx: TransformerContextProvider, type: ObjectTypeDefinitionNode, operation: {
        fieldName: string;
        typeName: string;
        type: QueryFieldType | MutationFieldType | SubscriptionFieldType;
    }) => ObjectTypeDefinitionNode;
    // (undocumented)
    abstract getQueryFieldNames: (type: ObjectTypeDefinitionNode, directive?: DirectiveDefinitionNode) => Set<{
        fieldName: string;
        typeName: string;
        type: QueryFieldType;
    }>;
    // (undocumented)
    abstract getSubscriptionFieldNames: (type: ObjectTypeDefinitionNode, directive?: DirectiveDefinitionNode) => Set<{
        fieldName: string;
        typeName: string;
        type: SubscriptionFieldType;
    }>;
}

// @public (undocumented)
export abstract class TransformerModelEnhancerBase extends TransformerModelBase implements TransformerModelEnhancementProvider {
    constructor(name: string, doc: DocumentNode_2 | string, type?: TransformerPluginType);
}

// @public (undocumented)
export abstract class TransformerPluginBase implements TransformerPluginProvider {
    constructor(name: string, document: DocumentNode_2 | string, pluginType?: TransformerPluginType);
    // (undocumented)
    protected debug(message: string): void;
    // (undocumented)
    readonly directive: DirectiveDefinitionNode;
    // (undocumented)
    protected error(message: string): void;
    // (undocumented)
    getLogs(): TransformerLog[];
    // (undocumented)
    protected info(message: string): void;
    // (undocumented)
    readonly name: string;
    // (undocumented)
    readonly pluginType: TransformerPluginType;
    // (undocumented)
    readonly typeDefinitions: TypeDefinitionNode[];
    // (undocumented)
    protected warn(message: string): void;
}

// @public (undocumented)
export class TransformerResolver implements TransformerResolverProvider {
    constructor(typeName: string, fieldName: string, resolverLogicalId: string, mappingTemplate: FunctionRuntimeTemplate, requestSlots: string[], responseSlots: string[], datasource?: DataSourceProvider | undefined, runtime?: CfnFunctionConfiguration.AppSyncRuntimeProperty | undefined);
    // (undocumented)
    addJsFunctionToSlot: (slotName: string, codeMappingTemplate: MappingTemplateProvider, dataSource?: DataSourceProvider) => void;
    // (undocumented)
    addVtlFunctionToSlot: (slotName: string, requestMappingTemplate?: MappingTemplateProvider, responseMappingTemplate?: MappingTemplateProvider, dataSource?: DataSourceProvider) => void;
    // Warning: (ae-forgotten-export) The symbol "Slot" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    findSlot: (slotName: string, mappingTemplate: FunctionRuntimeTemplatePartialVTL) => Slot | undefined;
    // (undocumented)
    mapToStack: (stack: Stack) => void;
    // (undocumented)
    setScope: (scope: Construct) => void;
    // Warning: (ae-forgotten-export) The symbol "FunctionRuntimeTemplatePartialVTL" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    slotExists: (slotName: string, mappingTemplate: FunctionRuntimeTemplatePartialVTL) => boolean;
    // (undocumented)
    synthesize: (context: TransformerContextProvider, api: GraphQLAPIProvider) => void;
    // (undocumented)
    synthesizeResolvers: (scope: Construct, api: GraphQLAPIProvider, slotsNames: string[]) => AppSyncFunctionConfigurationProvider[];
    // (undocumented)
    updateSlot: (slotName: string, mappingTemplate: FunctionRuntimeTemplatePartialVTL) => void;
}

// @public (undocumented)
export class UnknownDirectiveError extends Error {
    constructor(message: string);
}

// @public (undocumented)
export type UserDefinedResolver = {
    fileName: string;
    template: string;
};

// @public (undocumented)
export type UserDefinedSlot = {
    resolverTypeName: string;
    resolverFieldName: string;
    slotName: string;
    requestResolver?: UserDefinedResolver;
    responseResolver?: UserDefinedResolver;
};

// @public (undocumented)
export const validateModelSchema: (doc: DocumentNode) => readonly GraphQLError[];

// @public (undocumented)
function validateResolverConfigForType(ctx: TransformerSchemaVisitStepContextProvider, typeName: string): void;

// @public (undocumented)
export const VTL_RUNTIME: CfnFunctionConfiguration.AppSyncRuntimeProperty | undefined;

// Warnings were encountered during analysis:
//
// src/config/transformer-config.ts:26:3 - (ae-forgotten-export) The symbol "LambdaConflictHandler" needs to be exported by the entry point index.d.ts
// src/utils/ai/json-schema.ts:14:3 - (ae-forgotten-export) The symbol "JSONLike" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```