refine design

Author: hsubox76

common/api-review/vertexai-preview.api.md

@@ -9,6 +9,18 @@ import { FirebaseApp } from '@firebase/app';
 import { FirebaseAuthTokenData } from '@firebase/auth-interop-types';
 import { FirebaseError } from '@firebase/util';
 
+// @public (undocumented)
+export class ArraySchema extends Schema {
+    // Warning: (ae-forgotten-export) The symbol "SchemaParams" needs to be exported by the entry point index.d.ts
+    constructor(schemaParams: SchemaParams, items: TypedSchema);
+    // (undocumented)
+    items: TypedSchema;
+    // Warning: (ae-forgotten-export) The symbol "_SchemaRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    toJSON(): _SchemaRequest;
+}
+
 // @public
 export interface BaseParams {
     // (undocumented)
@@ -27,6 +39,11 @@ export enum BlockReason {
     SAFETY = "SAFETY"
 }
 
+// @public (undocumented)
+export class BooleanSchema extends Schema {
+    constructor(schemaParams?: SchemaParams);
+}
+
 // @public
 export class ChatSession {
     // Warning: (ae-forgotten-export) The symbol "ApiSettings" needs to be exported by the entry point index.d.ts
@@ -203,7 +220,6 @@ export interface FunctionCallPart {
 export interface FunctionDeclaration {
     description?: string;
     name: string;
-    // Warning: (ae-forgotten-export) The symbol "ObjectSchema" needs to be exported by the entry point index.d.ts
     parameters?: ObjectSchema;
 }
 
@@ -297,8 +313,6 @@ export interface GenerationConfig {
     // (undocumented)
     presencePenalty?: number;
     responseMimeType?: string;
-    // Warning: (ae-forgotten-export) The symbol "TypedSchema" needs to be exported by the entry point index.d.ts
-    //
     // (undocumented)
     responseSchema?: TypedSchema;
     // (undocumented)
@@ -448,6 +462,11 @@ export interface InlineDataPart {
     videoMetadata?: VideoMetadata;
 }
 
+// @public (undocumented)
+export class IntegerSchema extends Schema {
+    constructor(schemaParams?: SchemaParams);
+}
+
 // @public
 export interface ModelParams extends BaseParams {
     // (undocumented)
@@ -460,6 +479,24 @@ export interface ModelParams extends BaseParams {
     tools?: Tool[];
 }
 
+// @public (undocumented)
+export class NumberSchema extends Schema {
+    constructor(schemaParams?: SchemaParams);
+}
+
+// @public (undocumented)
+export class ObjectSchema extends Schema {
+    constructor(schemaParams: SchemaParams, properties: {
+        [k: string]: TypedSchema;
+    });
+    // (undocumented)
+    properties: {
+        [k: string]: TypedSchema;
+    };
+    // (undocumented)
+    toJSON(): _SchemaRequest;
+}
+
 // @public
 export type Part = TextPart | InlineDataPart | FunctionCallPart | FunctionResponsePart | FileDataPart;
 
@@ -519,6 +556,49 @@ export interface SafetySetting {
     threshold: HarmBlockThreshold;
 }
 
+// Warning: (ae-forgotten-export) The symbol "SchemaInterface" needs to be exported by the entry point index.d.ts
+//
+// @public (undocumented)
+export abstract class Schema implements SchemaInterface {
+    constructor(schemaParams: SchemaInterface);
+    // (undocumented)
+    static array(arrayParams: SchemaParams & {
+        items: Schema;
+    }): ArraySchema;
+    // (undocumented)
+    static boolean(booleanParams?: SchemaParams): BooleanSchema;
+    description?: string;
+    // (undocumented)
+    static enumString(stringParams: SchemaParams & {
+        enum: string[];
+    }): StringSchema;
+    example?: unknown;
+    format?: string;
+    // (undocumented)
+    static functionDeclaration(objectParams: SchemaParams & {
+        properties: {
+            [k: string]: Schema;
+        };
+    }): ObjectSchema;
+    // (undocumented)
+    static integer(integerParams?: SchemaParams): IntegerSchema;
+    nullable: boolean;
+    // (undocumented)
+    static number(numberParams?: SchemaParams): NumberSchema;
+    // (undocumented)
+    static object(objectParams: SchemaParams & {
+        properties: {
+            [k: string]: Schema;
+        };
+    }): ObjectSchema;
+    required: boolean;
+    // (undocumented)
+    static string(stringParams?: SchemaParams): StringSchema;
+    toJSON(): _SchemaRequest;
+    // Warning: (ae-forgotten-export) The symbol "SchemaType" needs to be exported by the entry point index.d.ts
+    type: SchemaType;
+}
+
 // @public (undocumented)
 export interface Segment {
     // (undocumented)
@@ -541,6 +621,15 @@ export interface StartChatParams extends BaseParams {
     tools?: Tool[];
 }
 
+// @public (undocumented)
+export class StringSchema extends Schema {
+    constructor(schemaParams?: SchemaParams, enumValues?: string[]);
+    // (undocumented)
+    enum?: string[];
+    // (undocumented)
+    toJSON(): _SchemaRequest;
+}
+
 // @public
 export interface TextPart {
     // (undocumented)
@@ -562,6 +651,9 @@ export interface ToolConfig {
     functionCallingConfig: FunctionCallingConfig;
 }
 
+// @public (undocumented)
+export type TypedSchema = IntegerSchema | NumberSchema | StringSchema | BooleanSchema | ObjectSchema | ArraySchema;
+
 // @public
 export interface UsageMetadata {
     // (undocumented)

packages/vertexai/src/requests/schema-builder.test.ts

@@ -23,38 +23,38 @@ use(sinonChai);
 
 describe.only('Schema builder', () => {
   it('builds integer schema', () => {
-    const schema = Schema.createInteger();
+    const schema = Schema.integer();
     expect(schema.toJSON()).to.eql({
       type: 'integer',
       nullable: false
     });
   });
   it('builds number schema', () => {
-    const schema = Schema.createNumber();
+    const schema = Schema.number();
     expect(schema.toJSON()).to.eql({
       type: 'number',
       nullable: false
     });
   });
   it('builds boolean schema', () => {
-    const schema = Schema.createBoolean();
+    const schema = Schema.boolean();
     expect(schema.toJSON()).to.eql({
       type: 'boolean',
       nullable: false
     });
   });
   it('builds string schema', () => {
-    const schema = Schema.createString({ description: 'hey' });
+    const schema = Schema.string({ description: 'hey' });
     expect(schema.toJSON()).to.eql({
       type: 'string',
       description: 'hey',
       nullable: false
     });
   });
   it('builds enumString schema', () => {
-    const schema = Schema.createEnumString({
+    const schema = Schema.enumString({
       example: 'east',
-      enumValues: ['east', 'west']
+      enum: ['east', 'west']
     });
     expect(schema.toJSON()).to.eql({
       type: 'string',
@@ -64,9 +64,9 @@ describe.only('Schema builder', () => {
     });
   });
   it('builds functionDeclaration schema', () => {
-    const schema = Schema.createFunctionDeclaration({
+    const schema = Schema.functionDeclaration({
       properties: {
-        'someInput': Schema.createString()
+        'someInput': Schema.string()
       }
     });
     expect(schema.toJSON()).to.eql({
@@ -82,39 +82,39 @@ describe.only('Schema builder', () => {
     });
   });
   it('builds layered schema', () => {
-    const schema = Schema.createArray({
-      items: Schema.createObject({
+    const schema = Schema.array({
+      items: Schema.object({
         properties: {
-          country: Schema.createString({
+          country: Schema.string({
             description: 'some country',
             required: true
           }),
-          population: Schema.createInteger(),
-          coordinates: Schema.createObject({
+          population: Schema.integer(),
+          coordinates: Schema.object({
             properties: {
-              latitude: Schema.createNumber({ format: 'float' }),
-              longitude: Schema.createNumber({ format: 'double' })
+              latitude: Schema.number({ format: 'float' }),
+              longitude: Schema.number({ format: 'double' })
             }
           }),
-          hemisphere: Schema.createObject({
+          hemisphere: Schema.object({
             properties: {
-              latitudinal: Schema.createEnumString({ enumValues: ['N', 'S'] }),
-              longitudinal: Schema.createEnumString({ enumValues: ['E', 'W'] })
+              latitudinal: Schema.enumString({ enum: ['N', 'S'] }),
+              longitudinal: Schema.enumString({ enum: ['E', 'W'] })
             }
           }),
-          isCapital: Schema.createBoolean()
+          isCapital: Schema.boolean()
         }
       })
     });
 
     expect(schema.toJSON()).to.eql(layeredSchemaOutput);
   });
   it('can override the "required" and "nullable" properties', () => {
-    const schema = Schema.createObject({
+    const schema = Schema.object({
       properties: {
-        country: Schema.createString(),
-        elevation: Schema.createNumber({ required: false }),
-        population: Schema.createInteger({ nullable: true })
+        country: Schema.string(),
+        elevation: Schema.number({ required: false }),
+        population: Schema.integer({ nullable: true })
       }
     });
     expect(schema.toJSON()).to.eql({