@conduit-client/model 3.7.0 → 3.8.0

package/dist/types/v1/{amf → parser/amf}/index.d.ts

@@ -1,5 +1,4 @@
 export * from './amf-api-service';
 export * from './types';
-export { V1_VERSION } from './AMFAPI';
 export { getAmfAnnotationVersion } from './version';
 export { parseAmfDocument, parseUrl } from './parser';

package/dist/types/v1/{amf → parser/amf}/types/AMFAllOfType.d.ts

@@ -1,6 +1,6 @@
 import { AMFBaseType } from './AMFBaseType';
 import type { AMFType } from '.';
-import type { AllOfType, DiscriminatedObjectType, Type } from '../../types';
+import type { AllOfType, DiscriminatedObjectType, Type } from '../../../types';
 import type amf from 'amf-client-js';
 export type AMFAllOfType = AMFType & AllOfType;
 export declare class AMFAllOfTypeImpl extends AMFBaseType<'allOf', amf.AnyShape> implements AMFAllOfType {
@@ -18,6 +18,6 @@ export declare class AMFAllOfTypeImpl extends AMFBaseType<'allOf', amf.AnyShape>
         key: {
             fields: Record<string, string>;
         };
-        'cache-control': import("../..").TypeCacheControlExtension;
+        'cache-control': import("../../..").TypeCacheControlExtension;
     };
 }

package/dist/types/v1/{amf → parser/amf}/types/AMFAnyType.d.ts

@@ -1,6 +1,6 @@
 import { AMFBaseType } from './AMFBaseType';
 import type { AMFType } from '.';
-import type { AnyType } from '../../types';
+import type { AnyType } from '../../../types';
 export type AMFAnyType = AMFType & AnyType;
 export declare class AMFAnyTypeImpl extends AMFBaseType<'any'> implements AMFAnyType {
     type: "any";

package/dist/types/v1/{amf → parser/amf}/types/AMFArrayType.d.ts

@@ -1,7 +1,7 @@
 import { AMFBaseType } from './AMFBaseType';
 import type amf from 'amf-client-js';
 import type { AMFType } from '.';
-import type { ArrayType, Type } from '../../types';
+import type { ArrayType, Type } from '../../../types';
 export type AMFArrayType = AMFType & ArrayType;
 export declare class AMFArrayTypeImpl extends AMFBaseType<'array', amf.ArrayShape> implements AMFArrayType {
     type: "array";

package/dist/types/v1/{amf → parser/amf}/types/AMFBaseType.d.ts

@@ -1,9 +1,9 @@
 import type { AMFTypeFactory } from './factory';
 import type amf from 'amf-client-js';
-import type { BaseType, Type, TypeExtensions, TypeRegistry } from '../../types';
+import type { BaseType, Type, TypeExtensions, TypeRegistry } from '../../../types';
 import type { AMFType } from '.';
 import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
-import type { API } from '../../api';
+import type { API } from '../../../api';
 export declare abstract class AMFBaseType<T extends Type['type'], S extends amf.AnyShape = amf.AnyShape> implements BaseType {
     api: API;
     shape: S;

package/dist/types/v1/{amf → parser/amf}/types/AMFDiscriminatedObjectType.d.ts

@@ -1,7 +1,7 @@
 import { AMFObjectType, type AMFType, type AMFTypeFactory, AMFTypeProps } from './index';
 import type amf from 'amf-client-js';
-import type { DiscriminatedObjectType, Type, TypeRegistry } from '../../types';
-import type { API } from '../../api';
+import type { DiscriminatedObjectType, Type, TypeRegistry } from '../../../types';
+import type { API } from '../../../api';
 import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
 import { AMFBaseType } from './AMFBaseType';
 export type AMFDiscriminatedObjectType = AMFTypeProps<amf.NodeShape> & DiscriminatedObjectType;

package/dist/types/v1/{amf → parser/amf}/types/AMFEnumType.d.ts

@@ -1,10 +1,10 @@
 import { AMFBaseType } from './AMFBaseType';
 import type { AMFType, AMFTypeFactory, AMFTypeProps } from '.';
-import type { EnumType } from '../../types';
+import type { EnumType } from '../../../types';
 import type amf from 'amf-client-js';
-import type { TypeRegistry } from '../../types';
+import type { TypeRegistry } from '../../../types';
 import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
-import type { API } from '../../api';
+import type { API } from '../../../api';
 export type AMFEnumType = AMFTypeProps & EnumType;
 export declare class AMFEnumTypeImpl extends AMFBaseType<'enum'> implements AMFEnumType {
     shape: amf.NodeShape;

package/dist/types/v1/{amf → parser/amf}/types/AMFNilType.d.ts

@@ -1,6 +1,6 @@
 import { AMFBaseType } from './AMFBaseType';
 import type { AMFTypeProps } from '.';
-import type { NilType } from '../../types';
+import type { NilType } from '../../../types';
 export type AMFNilType = AMFTypeProps & NilType;
 export declare class AMFNilTypeImpl extends AMFBaseType<'nil'> implements AMFNilType {
     type: "nil";

package/dist/types/v1/{amf → parser/amf}/types/AMFNotType.d.ts

@@ -1,10 +1,10 @@
 import { AMFBaseType } from './AMFBaseType';
 import type { AMFType, AMFTypeFactory, AMFTypeProps } from '.';
-import type { NotType, Type } from '../../types';
+import type { NotType, Type } from '../../../types';
 import type amf from 'amf-client-js';
-import type { TypeRegistry } from '../../types';
+import type { TypeRegistry } from '../../../types';
 import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
-import type { API } from '../../api';
+import type { API } from '../../../api';
 export type AMFNotType = AMFTypeProps<amf.NodeShape> & NotType;
 export declare class AMFNotTypeImpl extends AMFBaseType<'not', amf.NodeShape> implements AMFNotType {
     shape: amf.NodeShape;

package/dist/types/v1/{amf → parser/amf}/types/AMFObjectType.d.ts

@@ -1,7 +1,7 @@
 import { AMFBaseType } from './AMFBaseType';
 import type amf from 'amf-client-js';
 import type { AMFTypeProps } from '.';
-import type { Property, ObjectType, Type } from '../../types';
+import type { Property, ObjectType, Type } from '../../../types';
 export type AMFObjectType = AMFTypeProps<amf.NodeShape> & ObjectType;
 export declare class AMFObjectTypeImpl extends AMFBaseType<'object', amf.NodeShape> implements AMFObjectType {
     type: "object";

package/dist/types/v1/{amf → parser/amf}/types/AMFOneOfType.d.ts

@@ -1,6 +1,6 @@
 import { AMFBaseType } from './AMFBaseType';
 import type { AMFType } from '.';
-import type { OneOf } from '../../types';
+import type { OneOf } from '../../../types';
 import type amf from 'amf-client-js';
 export type AMFOneOfType = AMFType & OneOf;
 export declare class AMFOneOfTypeImpl extends AMFBaseType<'oneOf', amf.UnionShape> implements AMFOneOfType {

package/dist/types/v1/{amf → parser/amf}/types/AMFRefType.d.ts

@@ -1,5 +1,5 @@
 import { AMFBaseType } from './AMFBaseType';
-import type { RefType, AMFType, Type } from '../..';
+import type { RefType, AMFType, Type } from '../../../';
 import type amf from 'amf-client-js';
 export type AMFRefType = AMFType & RefType;
 export declare class AMFRefTypeImpl extends AMFBaseType<'ref', amf.AnyShape> implements AMFRefType {

package/dist/types/v1/{amf → parser/amf}/types/AMFScalarTypes.d.ts

@@ -1,10 +1,10 @@
 import { AMFBaseType } from './AMFBaseType';
 import type amf from 'amf-client-js';
 import type { AMFTypeProps, AMFType, AMFTypeFactory } from '.';
-import type { BooleanType, DateTimeOnlyType, DateTimeType, DateType, DoubleType, IntegerType, NumberType, ScalarType, StringType, TimeType } from '../../types';
-import type { TypeRegistry } from '../../types';
+import type { BooleanType, DateTimeOnlyType, DateTimeType, DateType, DoubleType, IntegerType, NumberType, ScalarType, StringType, TimeType } from '../../../types';
+import type { TypeRegistry } from '../../../types';
 import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
-import type { API } from '../../api';
+import type { API } from '../../../api';
 export type AMFBooleanType = AMFTypeProps & BooleanType;
 export type AMFDoubleType = AMFTypeProps & DoubleType;
 export type AMFIntegerType = AMFTypeProps & IntegerType;

package/dist/types/v1/parser/amf/types/__tests__/AMFOneOfType.spec.d.ts

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

package/dist/types/v1/parser/amf/types/__tests__/AMFScalarType.spec.d.ts

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

package/dist/types/v1/{amf → parser/amf}/types/factory.d.ts

@@ -1,8 +1,8 @@
 import type amf from 'amf-client-js';
 import type { AMFType } from '.';
-import type { TypeRegistry, Type } from '../../types';
+import type { TypeRegistry, Type } from '../../../types';
 import type { FileParserLogger, LoggerService } from '@conduit-client/utils';
-import type { API } from '../../api';
+import type { API } from '../../../api';
 /**
  * Constructs an AMFType based on the provided AMF Shape and a set of parameters that guide the creation process.
  *

package/dist/types/v1/{amf → parser/amf}/types/index.d.ts

@@ -1,5 +1,5 @@
 import type amf from 'amf-client-js';
-import type { Type } from '../../types';
+import type { Type } from '../../../types';
 export type AMFTypeProps<S extends amf.AnyShape = amf.AnyShape> = {
     shape: S;
     resolve: () => void;
@@ -13,4 +13,3 @@ export * from './AMFNilType';
 export * from './AMFScalarTypes';
 export * from './AMFOneOfType';
 export * from './factory';
-export * from './annotations-schemas';

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

@@ -0,0 +1,10 @@
+import { API, APIService } from '../api';
+export declare const V1_VERSION = "1.0.0";
+export declare const ANONYMOUS_TYPE_NAME = "<anonymous>";
+/**
+ * Wraps an already-created API in an APIService.
+ *
+ * @param api an API
+ * @returns
+ */
+export declare function asAPIService(api: API): APIService;

package/dist/types/v1/parser/zod-schemas.d.ts

@@ -0,0 +1,445 @@
+import { z } from 'zod';
+import { CacheStrategy } from '../api';
+export declare const rootExtensionSchema: z.ZodObject<{
+    onestore: z.ZodObject<{
+        version: z.ZodEffects<z.ZodString, import("@conduit-client/utils").Version, string>;
+    }, "strip", z.ZodTypeAny, {
+        version: import("@conduit-client/utils").Version;
+    }, {
+        version: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    onestore: {
+        version: import("@conduit-client/utils").Version;
+    };
+}, {
+    onestore: {
+        version: string;
+    };
+}>;
+export declare const cacheControl: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"max-age">;
+    'max-age': z.ZodNumber;
+    'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    'max-age': number;
+    type: "max-age";
+    'stale-while-revalidate'?: number | undefined;
+}, {
+    'max-age': number;
+    type: "max-age";
+    'stale-while-revalidate'?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"no-cache">;
+}, "strip", z.ZodTypeAny, {
+    type: "no-cache";
+}, {
+    type: "no-cache";
+}>]>;
+export declare const resourceCacheControl: z.ZodObject<{
+    'max-age': z.ZodNumber;
+    'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    'max-age': number;
+    'stale-while-revalidate'?: number | undefined;
+}, {
+    'max-age': number;
+    'stale-while-revalidate'?: number | undefined;
+}>;
+export declare const operationCacheStrategy: (defaultCacheStrategyType?: Pick<CacheStrategy, "type">) => z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"none">;
+}, "strict", z.ZodTypeAny, {
+    type: "none";
+}, {
+    type: "none";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"resource">;
+    config: z.ZodObject<{
+        'max-age': z.ZodNumber;
+        'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    }, {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    type: "resource";
+    config: {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    };
+}, {
+    type: "resource";
+    config: {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"normalized">;
+    'cache-control': z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"max-age">;
+        'max-age': z.ZodNumber;
+        'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    }, {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"no-cache">;
+    }, "strip", z.ZodTypeAny, {
+        type: "no-cache";
+    }, {
+        type: "no-cache";
+    }>]>>;
+    key: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Record<string, string>, Record<string, string>>>;
+}, "strict", z.ZodTypeAny, {
+    type: "normalized";
+    key?: Record<string, string> | undefined;
+    'cache-control'?: {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    } | undefined;
+}, {
+    type: "normalized";
+    key?: Record<string, string> | undefined;
+    'cache-control'?: {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    } | undefined;
+}>]>, {
+    type: "none";
+} | {
+    type: "resource";
+    config: {
+        'max-age': number;
+        'stale-while-revalidate'?: number | undefined;
+    };
+} | {
+    type: "normalized";
+    key?: Record<string, string> | undefined;
+    'cache-control'?: {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    } | undefined;
+}, unknown>;
+export declare const typeExtensions: z.ZodObject<{
+    key: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        fields: Record<string, string>;
+    }, {
+        fields: Record<string, string>;
+    }>;
+    'cache-control': z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"max-age">;
+        'max-age': z.ZodNumber;
+        'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    }, {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"no-cache">;
+    }, "strip", z.ZodTypeAny, {
+        type: "no-cache";
+    }, {
+        type: "no-cache";
+    }>]>;
+}, "strict", z.ZodTypeAny, {
+    key: {
+        fields: Record<string, string>;
+    };
+    'cache-control': {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    };
+}, {
+    key: {
+        fields: Record<string, string>;
+    };
+    'cache-control': {
+        'max-age': number;
+        type: "max-age";
+        'stale-while-revalidate'?: number | undefined;
+    } | {
+        type: "no-cache";
+    };
+}>;
+export declare const baseExtensionsSchema: z.ZodObject<{
+    onestore: z.ZodObject<{
+        defaults: z.ZodOptional<z.ZodObject<{
+            operations: z.ZodOptional<z.ZodObject<{
+                'cache-strategy': z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                    type: z.ZodLiteral<"none">;
+                }, "strict", z.ZodTypeAny, {
+                    type: "none";
+                }, {
+                    type: "none";
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"resource">;
+                }, "strict", z.ZodTypeAny, {
+                    type: "resource";
+                }, {
+                    type: "resource";
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"normalized">;
+                }, "strict", z.ZodTypeAny, {
+                    type: "normalized";
+                }, {
+                    type: "normalized";
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                'cache-strategy': {
+                    type: "none";
+                } | {
+                    type: "resource";
+                } | {
+                    type: "normalized";
+                };
+            }, {
+                'cache-strategy': {
+                    type: "none";
+                } | {
+                    type: "resource";
+                } | {
+                    type: "normalized";
+                };
+            }>>;
+            schemas: z.ZodOptional<z.ZodObject<{
+                'cache-control': z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                    type: z.ZodLiteral<"max-age">;
+                    'max-age': z.ZodNumber;
+                    'stale-while-revalidate': z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                }, {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"no-cache">;
+                }, "strip", z.ZodTypeAny, {
+                    type: "no-cache";
+                }, {
+                    type: "no-cache";
+                }>]>;
+            }, "strip", z.ZodTypeAny, {
+                'cache-control': {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                } | {
+                    type: "no-cache";
+                };
+            }, {
+                'cache-control': {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                } | {
+                    type: "no-cache";
+                };
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            operations?: {
+                'cache-strategy': {
+                    type: "none";
+                } | {
+                    type: "resource";
+                } | {
+                    type: "normalized";
+                };
+            } | undefined;
+            schemas?: {
+                'cache-control': {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                } | {
+                    type: "no-cache";
+                };
+            } | undefined;
+        }, {
+            operations?: {
+                'cache-strategy': {
+                    type: "none";
+                } | {
+                    type: "resource";
+                } | {
+                    type: "normalized";
+                };
+            } | undefined;
+            schemas?: {
+                'cache-control': {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                } | {
+                    type: "no-cache";
+                };
+            } | undefined;
+        }>>;
+        services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodString;
+            version: z.ZodString;
+            tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            default: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }>>>;
+        namespace: z.ZodOptional<z.ZodString>;
+        version: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        version: string;
+        services?: Record<string, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }> | undefined;
+        defaults?: {
+            operations?: {
+                'cache-strategy': {
+                    type: "none";
+                } | {
+                    type: "resource";
+                } | {
+                    type: "normalized";
+                };
+            } | undefined;
+            schemas?: {
+                'cache-control': {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                } | {
+                    type: "no-cache";
+                };
+            } | undefined;
+        } | undefined;
+        namespace?: string | undefined;
+    }, {
+        version: string;
+        services?: Record<string, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }> | undefined;
+        defaults?: {
+            operations?: {
+                'cache-strategy': {
+                    type: "none";
+                } | {
+                    type: "resource";
+                } | {
+                    type: "normalized";
+                };
+            } | undefined;
+            schemas?: {
+                'cache-control': {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                } | {
+                    type: "no-cache";
+                };
+            } | undefined;
+        } | undefined;
+        namespace?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    onestore: {
+        version: string;
+        services?: Record<string, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }> | undefined;
+        defaults?: {
+            operations?: {
+                'cache-strategy': {
+                    type: "none";
+                } | {
+                    type: "resource";
+                } | {
+                    type: "normalized";
+                };
+            } | undefined;
+            schemas?: {
+                'cache-control': {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                } | {
+                    type: "no-cache";
+                };
+            } | undefined;
+        } | undefined;
+        namespace?: string | undefined;
+    };
+}, {
+    onestore: {
+        version: string;
+        services?: Record<string, {
+            type: string;
+            version: string;
+            tags?: Record<string, string> | undefined;
+            default?: boolean | undefined;
+        }> | undefined;
+        defaults?: {
+            operations?: {
+                'cache-strategy': {
+                    type: "none";
+                } | {
+                    type: "resource";
+                } | {
+                    type: "normalized";
+                };
+            } | undefined;
+            schemas?: {
+                'cache-control': {
+                    'max-age': number;
+                    type: "max-age";
+                    'stale-while-revalidate'?: number | undefined;
+                } | {
+                    type: "no-cache";
+                };
+            } | undefined;
+        } | undefined;
+        namespace?: string | undefined;
+    };
+}>;