@conduit-client/model 5.67.0-dev1

package/dist/types/v1/api/validation/operation/Response200Validator.d.ts

@@ -0,0 +1,96 @@
+import type { Operation } from '../../..';
+import { Validator } from '../../../validation';
+/**
+ * Validates that normalized operations define a 200-level JSON response
+ */
+export declare class Response200Validator<T extends Operation = Operation> implements Validator<T, Operation> {
+    validate(operation: T): import("@conduit-client/utils").Ok<never[], never> | import("@conduit-client/utils").Err<never, import("../../../validation").ValidationMessage<(T & import("../..").BaseOperation<import("../../..").Type, import("../../..").Type> & {
+        type: "aura";
+        aura: {
+            methodName: string;
+        };
+    } & {
+        cacheStrategy: {
+            type: "normalized";
+        };
+    }) | (T & import("../..").BaseOperation<import("../../..").Type, import("../../..").Type> & {
+        configBodyParam: string;
+    } & {
+        type: "aura";
+        aura: {
+            methodName: string;
+        };
+    } & {
+        aura: import("../..").BaseAuraOperation["aura"] & {
+            bodyParam: string;
+        };
+    } & {
+        cacheStrategy: {
+            type: "normalized";
+        };
+    }) | (T & import("../..").BaseOperation<import("../../..").Type, import("../../..").Type> & {
+        type: "http";
+    } & {
+        cacheStrategy: {
+            type: "normalized";
+        };
+    }) | (T & import("../..").BaseOperation<import("../../..").Type, import("../../..").Type> & {
+        type: "http";
+    } & {
+        configBodyParam: string;
+    } & {
+        cacheStrategy: {
+            type: "normalized";
+        };
+    }) | (T & import("../..").BaseOperation<import("../../..").Type, import("../../..").Type> & {
+        type: "aura";
+        aura: {
+            methodName: string;
+        };
+    } & {
+        operationType: "graphql";
+        graphqlConfig: import("../..").GraphQLConfig;
+    } & {
+        cacheStrategy: {
+            type: "normalized";
+        };
+    }) | (T & import("../..").BaseOperation<import("../../..").Type, import("../../..").Type> & {
+        configBodyParam: string;
+    } & {
+        type: "aura";
+        aura: {
+            methodName: string;
+        };
+    } & {
+        aura: import("../..").BaseAuraOperation["aura"] & {
+            bodyParam: string;
+        };
+    } & {
+        operationType: "graphql";
+        graphqlConfig: import("../..").GraphQLConfig;
+    } & {
+        cacheStrategy: {
+            type: "normalized";
+        };
+    }) | (T & import("../..").BaseOperation<import("../../..").Type, import("../../..").Type> & {
+        type: "http";
+    } & {
+        operationType: "graphql";
+        graphqlConfig: import("../..").GraphQLConfig;
+    } & {
+        cacheStrategy: {
+            type: "normalized";
+        };
+    }) | (T & import("../..").BaseOperation<import("../../..").Type, import("../../..").Type> & {
+        type: "http";
+    } & {
+        configBodyParam: string;
+    } & {
+        operationType: "graphql";
+        graphqlConfig: import("../..").GraphQLConfig;
+    } & {
+        cacheStrategy: {
+            type: "normalized";
+        };
+    })>[]>;
+}

package/dist/types/v1/api/validation/operation/__tests__/BodyDataValidator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/api/validation/operation/__tests__/InvalidationValidator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/api/validation/operation/__tests__/KeyMatchValidator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/api/validation/operation/__tests__/KeySourceValidator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/api/validation/operation/__tests__/NoNormalizedTypesValidator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/api/validation/operation/__tests__/Response200Validator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/api/validation/operation/__tests__/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/api/validation/operation/__tests__/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/api/validation/operation/index.d.ts

@@ -0,0 +1,3 @@
+import { API, Operation, Type } from '../../..';
+import { Validator } from '../../../validation';
+export declare function buildOperationValidator(api: API): Validator<Operation, Operation | Type>;

package/dist/types/v1/api/validation/operation/utils.d.ts

@@ -0,0 +1,4 @@
+import { NormalizedOperation, Operation } from '../../endpoint';
+import { ValidationMessage, ValidationSeverity } from '../../../validation';
+export declare function isNormalizedOperation(operation: Operation): operation is NormalizedOperation;
+export declare function getFormattedMessage<T = Operation>(subject: T, message: string, severity?: ValidationSeverity): ValidationMessage<T>;

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

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './types';
+export * from './amf';

package/dist/types/v1/types/Type.d.ts

@@ -0,0 +1,106 @@
+export type TypeCacheControlExtension = {
+    type: 'max-age';
+    'max-age': number;
+    'stale-while-revalidate'?: number;
+} | {
+    type: 'no-cache';
+};
+export type TypeExtensions = {
+    type: 'unidentifiable';
+} | {
+    type: 'identifiable';
+    key: {
+        fields: Record<string, string>;
+    };
+    'cache-control': TypeCacheControlExtension;
+};
+export type BaseType = {
+    type: string;
+    extensions?: TypeExtensions;
+};
+export type NilType = {
+    type: 'nil';
+} & BaseType;
+export type BooleanType = {
+    type: 'boolean';
+} & BaseType;
+export type DoubleType = {
+    type: 'double';
+} & BaseType;
+export type IntegerType = {
+    type: 'integer';
+} & BaseType;
+export type NumberType = {
+    type: 'number';
+} & BaseType;
+export type StringType = {
+    type: 'string';
+} & BaseType;
+export type DateType = {
+    type: 'date';
+} & BaseType;
+export type TimeType = {
+    type: 'time';
+} & BaseType;
+export type DateTimeOnlyType = {
+    type: 'datetime-only';
+} & BaseType;
+export type DateTimeType = {
+    type: 'datetime';
+    format: 'date' | 'date-time';
+} & BaseType;
+export type EnumType = {
+    type: 'enum';
+    values: Array<string | number | boolean | null>;
+} & BaseType;
+export type ScalarType = BooleanType | DoubleType | IntegerType | NumberType | StringType | DateType | TimeType | DateTimeOnlyType | DateTimeType;
+export type Property = {
+    type: Type;
+    required: boolean;
+};
+export type ObjectType = {
+    type: 'object';
+    properties: Record<string, Property>;
+    additionalProperties: Type;
+} & BaseType;
+export type DiscriminatedObjectType = {
+    type: 'discriminatedObject';
+    discriminator: string;
+    mapping: Record<string, Type>;
+    baseType: ObjectType;
+} & BaseType;
+export type ArrayType = {
+    type: 'array';
+    items: Type;
+} & BaseType;
+export type OneOf = {
+    type: 'oneOf';
+    oneOf: Type[];
+} & BaseType;
+export type AllOfType = {
+    type: 'allOf';
+    allOf: Type[];
+    includes: (t: Type) => boolean;
+} & BaseType;
+export type AnyType = {
+    type: 'any';
+} & BaseType;
+export type NotType = {
+    type: 'not';
+    not: Type;
+} & BaseType;
+export type RefType = {
+    type: 'ref';
+    $ref: Type;
+} & BaseType;
+export type Type = ScalarType | NilType | DiscriminatedObjectType | ObjectType | ArrayType | OneOf | AllOfType | AnyType | NotType | EnumType | RefType;
+export type IdentifiableType = Type & {
+    extensions: {
+        type: 'identifiable';
+    };
+};
+export type UnidentifiableType = Type & {
+    extensions?: {
+        type: 'unidentifiable';
+    };
+};

package/dist/types/v1/types/TypeRegistry.d.ts

@@ -0,0 +1,19 @@
+import type { Type } from './Type';
+type TypeRegistryExtensions<SupportedTypes> = {
+    /**
+     * Returns the name of the given type within this regstry; undefined if the type is not
+     * present in the registry.
+     *
+     * @param t SupportedType
+     */
+    nameOf(t: SupportedTypes): string | undefined;
+};
+export type ReadOnlyTypeRegistry<SupportedTypes extends Type = Type> = ReadonlyMap<string, SupportedTypes> & TypeRegistryExtensions<SupportedTypes>;
+export type TypeRegistry<SupportedTypes extends Type = Type> = Map<string, SupportedTypes> & TypeRegistryExtensions<SupportedTypes>;
+/**
+ * Base implementation of TypeRegistry.
+ */
+export declare class BaseTypeRegistry<SupportedTypes extends Type = Type> extends Map<string, SupportedTypes> implements TypeRegistry<SupportedTypes> {
+    nameOf(t: SupportedTypes): string | undefined;
+}
+export {};

package/dist/types/v1/types/__tests__/TypeRegistry.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/types/__tests__/types-equal.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/types/__tests__/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+export * from './Type';
+export * from './TypeRegistry';
+export { buildTypeValidator } from './validators';
+export * from './utils';
+export * from './types-equal';

package/dist/types/v1/types/types-equal.d.ts

@@ -0,0 +1,2 @@
+import { Type } from './Type';
+export declare function typesEqual(a: Type, b: Type): boolean;

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

@@ -0,0 +1,27 @@
+import { AllOfType, AnyType, ArrayType, BooleanType, DateTimeOnlyType, DateTimeType, DateType, DiscriminatedObjectType, DoubleType, EnumType, IdentifiableType, IntegerType, NilType, NotType, NumberType, ObjectType, OneOf, RefType, ScalarType, StringType, TimeType, Type } from './Type';
+export declare function isRefType(type: Type): type is RefType;
+export declare function isNilType(type: Type): type is NilType;
+export declare function isBooleanType(type: Type): type is BooleanType;
+export declare function isDoubleType(type: Type): type is DoubleType;
+export declare function isIntegerType(type: Type): type is IntegerType;
+export declare function isNumberType(type: Type): type is NumberType;
+export declare function isStringType(type: Type): type is StringType;
+export declare function isDateType(type: Type): type is DateType;
+export declare function isTimeType(type: Type): type is TimeType;
+export declare function isDateTimeOnlyType(type: Type): type is DateTimeOnlyType;
+export declare function isDateTimeType(type: Type): type is DateTimeType;
+export declare function isEnumType(type: Type): type is EnumType;
+export declare function isObjectType(type: Type): type is ObjectType;
+export declare function isDiscriminatedObjectType(type: Type): type is DiscriminatedObjectType;
+export declare function isArrayType(type: Type): type is ArrayType;
+export declare function isOneOfType(type: Type): type is OneOf;
+export declare function isAllOfType(type: Type): type is AllOfType;
+export declare function isAnyType(type: Type): type is AnyType;
+export declare function isNotType(type: Type): type is NotType;
+export declare function isScalar(type: Type): type is ScalarType;
+export declare function isCanonicalStringType(type: Type): type is Type & {
+    type: 'string' | 'date' | 'time' | 'datetime-only' | 'datetime';
+};
+export declare function isCanonicalNumberType(type: Type): boolean;
+export declare function isIdentifiableType(type: Type): type is IdentifiableType;
+export declare function canonicalizeType(type: Type): Type;

package/dist/types/v1/types/validators/__tests__/common.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/types/validators/__tests__/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/types/validators/common.d.ts

@@ -0,0 +1,4 @@
+import { ValidationSeverity } from '../../validation';
+import type { ValidationMessage } from '../../validation';
+import type { Type } from '../Type';
+export declare function getFormattedMessage(subject: Type, message: string, severity?: ValidationSeverity): ValidationMessage<Type>;

package/dist/types/v1/types/validators/extensions/KeyFieldReferenceValidator.d.ts

@@ -0,0 +1,11 @@
+import { type Validator } from '../../../validation';
+import type { Type } from '../../Type';
+import { KeySourcesValidator } from './KeySourcesValidator';
+/**
+ * Validates that the fields in a key are valid.
+ */
+export declare class KeyFieldReferenceValidator implements Validator<Type, Type> {
+    private keySourcesValidatorSupplier;
+    constructor(keySourcesValidatorSupplier: (sources: string[]) => KeySourcesValidator);
+    validate(type: Type): import("../../../validation").ValidationResult<Type>;
+}

package/dist/types/v1/types/validators/extensions/KeyIsDefinedInSupportedTypeValidator.d.ts

@@ -0,0 +1,20 @@
+import type { ValidationMessage, Validator } from '../../../validation';
+import type { Type } from '../../Type';
+import type { ReadOnlyTypeRegistry } from '../../TypeRegistry';
+/**
+ * Validates that a given type does not include a `key` annotation in unsupported types,
+ * such as scalar or array types.
+ */
+export declare class KeyIsDefinedInSupportedTypeValidator implements Validator<Type, Type> {
+    private typeRegistry;
+    constructor(typeRegistry: ReadOnlyTypeRegistry);
+    /**
+     * Validates the specified type to ensure the `key` annotation is not defined on scalar
+     * or array types. Returns a validation result indicating if the type is valid and any
+     * error messages if it is not.
+     *
+     * @param type - The type to validate.
+     * @returns A `ValidationResult<Type>` object containing the validation outcome and any error messages.
+     */
+    validate(type: Type): import("@conduit-client/utils").Ok<ValidationMessage<Type>[], never> | import("@conduit-client/utils").Err<never, ValidationMessage<Type>[]>;
+}

package/dist/types/v1/types/validators/extensions/KeySourcesValidator.d.ts

@@ -0,0 +1,25 @@
+import { ValidationResult, Validator } from '../../../validation';
+import type { Type } from '../../Type';
+import { ReadOnlyTypeRegistry } from '../../TypeRegistry';
+/**
+ * Validates that sources used by a types key are valid
+ */
+export declare class KeySourcesValidator implements Validator<Type, Type> {
+    private types;
+    private sources;
+    constructor(types: ReadOnlyTypeRegistry, sources: string[]);
+    validate(type: Type): ValidationResult<Type>;
+    private getNameOf;
+    private isValidFieldKeyForType;
+    private validateFieldInOneOfType;
+    private validateFieldInAllOfType;
+    private validateFieldForDiscriminatedObjectType;
+    private validateFieldInSubTypes;
+    private validateFieldForObjectType;
+    private validateAccessors;
+    /**
+     * Detects the nullable identifiable pattern: a oneOf type with exactly
+     * two members (object + null) where the type has identifiable extensions.
+     */
+    private isNullableIdentifiablePattern;
+}

package/dist/types/v1/types/validators/extensions/__tests__/KeyFieldReferenceValidator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/types/validators/extensions/__tests__/KeyIsDefinedInSupportedTypeValidator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/types/validators/extensions/__tests__/KeySourcesValidator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/types/validators/extensions/index.d.ts

@@ -0,0 +1,3 @@
+export { KeyFieldReferenceValidator } from './KeyFieldReferenceValidator';
+export { KeyIsDefinedInSupportedTypeValidator } from './KeyIsDefinedInSupportedTypeValidator';
+export { KeySourcesValidator } from './KeySourcesValidator';

package/dist/types/v1/types/validators/index.d.ts

@@ -0,0 +1,4 @@
+import { type Validator } from '../../validation';
+import type { Type } from '../Type';
+import type { ReadOnlyTypeRegistry } from '../TypeRegistry';
+export declare function buildTypeValidator(types: ReadOnlyTypeRegistry): Validator<Type, Type>;

package/dist/types/v1/validation.d.ts

@@ -0,0 +1,29 @@
+import { type Result } from '@conduit-client/utils';
+export declare enum ValidationType {
+    Api = "api",
+    Type = "type",
+    Operation = "operation",
+    EndPoint = "endpoint"
+}
+export declare enum ValidationSeverity {
+    Info = "info",
+    Warning = "warn",
+    Error = "error"
+}
+export type ValidationMessage<T> = {
+    validationType: ValidationType;
+    subject: T;
+    severity: ValidationSeverity;
+    message: string;
+    subValidationMessages?: ValidationMessage<T>[];
+};
+export type ValidationResult<T> = Result<ValidationMessage<T>[], ValidationMessage<T>[]>;
+export interface Validator<Subject, MessageSource> {
+    validate(subject: Subject): ValidationResult<MessageSource>;
+}
+export declare function combineValidationResults<T>(results: ValidationResult<T>[]): ValidationResult<T>;
+/**
+ * Composes multiple validators into a single validator whose result is the
+ * combination of all individual validation results.
+ */
+export declare function compose<T, R>(validators: Validator<T, R>[]): Validator<T, R>;

package/dist/types/v1/zod-utils.d.ts

@@ -0,0 +1,2 @@
+import type { z } from 'zod';
+export declare function formatZodError(err: z.ZodError): string;