@oatfi/oatfi-sdk-ts 0.11.61 → 0.11.63

package/src/models/userresponsedto.ts

@@ -5,9 +5,23 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { UserRoleEnum, UserRoleEnum$inboundSchema } from "./userroleenum.js";
+
+/**
+ * Role of the user
+ */
+export const UserResponseDtoRole = {
+  InternalAdmin: "INTERNAL_ADMIN",
+  PartnerAdmin: "PARTNER_ADMIN",
+  User: "USER",
+} as const;
+/**
+ * Role of the user
+ */
+export type UserResponseDtoRole = ClosedEnum<typeof UserResponseDtoRole>;
 
 /**
  * Additional metadata for the user
@@ -38,7 +52,7 @@ export type UserResponseDto = {
   /**
    * Role of the user
    */
-  role?: UserRoleEnum | undefined;
+  role?: UserResponseDtoRole | undefined;
   /**
    * ID of the partner this user belongs to
    */
@@ -69,6 +83,11 @@ export type UserResponseDto = {
   updatedAt?: Date | undefined;
 };
 
+/** @internal */
+export const UserResponseDtoRole$inboundSchema: z.ZodNativeEnum<
+  typeof UserResponseDtoRole
+> = z.nativeEnum(UserResponseDtoRole);
+
 /** @internal */
 export const UserResponseDtoMetadata$inboundSchema: z.ZodType<
   UserResponseDtoMetadata,
@@ -92,23 +111,19 @@ export const UserResponseDto$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  object: z.string().default("user"),
-  id: z.string(),
-  first_name: z.string().optional(),
-  last_name: z.string().optional(),
-  email: z.string().optional(),
-  role: UserRoleEnum$inboundSchema.optional(),
-  partner: z.string().optional(),
-  organizations: z.array(z.string()).optional(),
-  last_login_at: z.string().datetime({ offset: true }).transform(v =>
-    new Date(v)
-  ).optional(),
-  created_by: z.string().optional(),
-  metadata: z.lazy(() => UserResponseDtoMetadata$inboundSchema).optional(),
-  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
-  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
-    .optional(),
+  object: types.string().default("user"),
+  id: types.string(),
+  first_name: types.optional(types.string()),
+  last_name: types.optional(types.string()),
+  email: types.optional(types.string()),
+  role: types.optional(UserResponseDtoRole$inboundSchema),
+  partner: types.optional(types.string()),
+  organizations: types.optional(z.array(types.string())),
+  last_login_at: types.optional(types.date()),
+  created_by: types.optional(types.string()),
+  metadata: types.optional(z.lazy(() => UserResponseDtoMetadata$inboundSchema)),
+  created_at: types.optional(types.date()),
+  updated_at: types.optional(types.date()),
 }).transform((v) => {
   return remap$(v, {
     "first_name": "firstName",

package/src/models/virtualaccountinfoitemdto.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
   LockboxAddressDto,
@@ -45,12 +46,12 @@ export const VirtualAccountInfoItemDto$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  payment_method_id: z.string(),
-  account_holder_business_external_id: z.string(),
-  account_holder_id: z.string().optional(),
-  account_number: z.string(),
-  routing_number: z.string(),
-  lockbox_address: LockboxAddressDto$inboundSchema.optional(),
+  payment_method_id: types.string(),
+  account_holder_business_external_id: types.string(),
+  account_holder_id: types.optional(types.string()),
+  account_number: types.string(),
+  routing_number: types.string(),
+  lockbox_address: types.optional(LockboxAddressDto$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
     "payment_method_id": "paymentMethodId",

package/src/models/volumecapconfigdto.ts

@@ -6,12 +6,13 @@ import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 /**
  * Volume cap cadence
  */
-export const Cadence = {
+export const VolumeCapConfigDtoCadence = {
   None: "NONE",
   Daily: "DAILY",
   Weekly: "WEEKLY",
@@ -20,7 +21,9 @@ export const Cadence = {
 /**
  * Volume cap cadence
  */
-export type Cadence = ClosedEnum<typeof Cadence>;
+export type VolumeCapConfigDtoCadence = ClosedEnum<
+  typeof VolumeCapConfigDtoCadence
+>;
 
 export type VolumeCapConfigDto = {
   /**
@@ -30,7 +33,7 @@ export type VolumeCapConfigDto = {
   /**
    * Volume cap cadence
    */
-  cadence: Cadence;
+  cadence: VolumeCapConfigDtoCadence;
   /**
    * Lending capital limit in USD
    */
@@ -38,11 +41,13 @@ export type VolumeCapConfigDto = {
 };
 
 /** @internal */
-export const Cadence$inboundSchema: z.ZodNativeEnum<typeof Cadence> = z
-  .nativeEnum(Cadence);
+export const VolumeCapConfigDtoCadence$inboundSchema: z.ZodNativeEnum<
+  typeof VolumeCapConfigDtoCadence
+> = z.nativeEnum(VolumeCapConfigDtoCadence);
 /** @internal */
-export const Cadence$outboundSchema: z.ZodNativeEnum<typeof Cadence> =
-  Cadence$inboundSchema;
+export const VolumeCapConfigDtoCadence$outboundSchema: z.ZodNativeEnum<
+  typeof VolumeCapConfigDtoCadence
+> = VolumeCapConfigDtoCadence$inboundSchema;
 
 /** @internal */
 export const VolumeCapConfigDto$inboundSchema: z.ZodType<
@@ -50,9 +55,9 @@ export const VolumeCapConfigDto$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  enabled: z.boolean(),
-  cadence: Cadence$inboundSchema,
-  amount: z.number(),
+  enabled: types.boolean(),
+  cadence: VolumeCapConfigDtoCadence$inboundSchema,
+  amount: types.number(),
 });
 /** @internal */
 export type VolumeCapConfigDto$Outbound = {
@@ -68,7 +73,7 @@ export const VolumeCapConfigDto$outboundSchema: z.ZodType<
   VolumeCapConfigDto
 > = z.object({
   enabled: z.boolean(),
-  cadence: Cadence$outboundSchema,
+  cadence: VolumeCapConfigDtoCadence$outboundSchema,
   amount: z.number(),
 });
 

package/src/sdk/onboardingterms.ts

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { onboardingTermsCreate } from "../funcs/onboardingTermsCreate.js";
+import { onboardingTermsGetAll } from "../funcs/onboardingTermsGetAll.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { PageIterator, unwrapResultIterator } from "../types/operations.js";
+
+export class OnboardingTerms extends ClientSDK {
+  /**
+   * Create a new onboarding terms acceptance record
+   *
+   * @remarks
+   * Creates a new agreement acceptance record. When a business entity accepts onboarding terms (via hosted flow or embedded component), a webhook event `agreement_acceptance.created` is automatically emitted to the partner's configured webhook endpoint. The event payload includes the business external ID, timestamp of acceptance, terms version identifier, and terms file URL.
+   */
+  async create(
+    request: models.CreateOnboardingTermsAcceptanceDto,
+    options?: RequestOptions,
+  ): Promise<models.OnboardingTermsAcceptanceResponseDto> {
+    return unwrapAsync(onboardingTermsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get onboarding terms acceptance records
+   */
+  async getAll(
+    request: operations.OnboardingTermsControllerFindAllRequest,
+    options?: RequestOptions,
+  ): Promise<
+    PageIterator<
+      operations.OnboardingTermsControllerFindAllResponse,
+      { cursor: string }
+    >
+  > {
+    return unwrapResultIterator(onboardingTermsGetAll(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sdk.ts

@@ -3,7 +3,6 @@
  */
 
 import { ClientSDK } from "../lib/sdks.js";
-import { AcceptanceTerms } from "./acceptanceterms.js";
 import { ApplicationFiles } from "./applicationfiles.js";
 import { Applications } from "./applications.js";
 import { Authentication } from "./authentication.js";
@@ -18,6 +17,7 @@ import { Files } from "./files.js";
 import { FinancialAccounts } from "./financialaccounts.js";
 import { Holds } from "./holds.js";
 import { IncreaseTransactions } from "./increasetransactions.js";
+import { OnboardingTerms } from "./onboardingterms.js";
 import { Originations } from "./originations.js";
 import { PaymentIntents } from "./paymentintents.js";
 import { Payments } from "./payments.js";
@@ -192,9 +192,9 @@ export class OatFiSDK extends ClientSDK {
     return (this._users ??= new Users(this._options));
   }
 
-  private _acceptanceTerms?: AcceptanceTerms;
-  get acceptanceTerms(): AcceptanceTerms {
-    return (this._acceptanceTerms ??= new AcceptanceTerms(this._options));
+  private _onboardingTerms?: OnboardingTerms;
+  get onboardingTerms(): OnboardingTerms {
+    return (this._onboardingTerms ??= new OnboardingTerms(this._options));
   }
 
   // #region sdk-class-body

package/src/types/defaultToZeroValue.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { type Unrecognized, unrecognized } from "./unrecognized.js";
+
+let globalCount = 0;
+let refCount = 0;
+
+export function defaultToZeroValue<T>(value: T): Unrecognized<T> {
+  globalCount++;
+  return unrecognized(value);
+}
+
+export function startCountingDefaultToZeroValue() {
+  refCount++;
+  const start = globalCount;
+  return {
+    /**
+     * Ends counting and returns the delta.
+     * @param delta - If provided, only this amount is added to the parent counter
+     *   (used for nested unions where we only want to record the winning option's count).
+     *   If not provided, records all counts since start().
+     */
+    end: (delta?: number) => {
+      const count = globalCount - start;
+      // Reset globalCount back to start, then add only the specified delta
+      globalCount = start + (delta ?? count);
+      if (--refCount === 0) globalCount = 0;
+      return count;
+    },
+  };
+}

package/src/types/index.ts

@@ -3,9 +3,11 @@
  */
 
 export { blobLikeSchema, isBlobLike } from "./blobs.js";
+export * from "./defaultToZeroValue.js";
 export type { ClosedEnum, OpenEnum } from "./enums.js";
 export type { Result } from "./fp.js";
 export type { PageIterator, Paginator } from "./operations.js";
 export { createPageIterator } from "./operations.js";
+export * from "./primitives.js";
 export { RFCDate } from "./rfcdate.js";
 export * from "./unrecognized.js";

package/src/types/primitives.ts

@@ -0,0 +1,148 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { defaultToZeroValue } from "./defaultToZeroValue.js";
+import { unrecognized } from "./unrecognized.js";
+
+export function string(): z.ZodType<string, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.string(),
+
+    // Null or undefined -> ""
+    zodDefaultToZeroValue(""),
+
+    // Any other value -> String(x)
+    z.any().transform((x) => unrecognized(JSON.stringify(x))),
+  ]);
+}
+
+export function boolean(): z.ZodType<boolean, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.boolean(),
+
+    // String "true" (case insensitive) -> true, "false" -> false
+    z.string().transform((x, ctx) => {
+      const lower = x.toLowerCase();
+      if (lower === "true") return unrecognized(true);
+      if (lower === "false") return unrecognized(false);
+      ctx.addIssue({
+        code: "invalid_type",
+        expected: "boolean",
+        received: "string",
+      });
+      return z.NEVER;
+    }),
+
+    zodDefaultToZeroValue(false),
+  ]);
+}
+
+export function number(): z.ZodType<number, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.number(),
+
+    // String -> Number
+    z.string().transform((x, ctx) => {
+      const num = Number(x);
+      if (isNaN(num)) {
+        ctx.addIssue({
+          code: "invalid_type",
+          expected: "number",
+          received: "string",
+        });
+        return z.NEVER;
+      }
+      return unrecognized(num);
+    }),
+
+    // Null or undefined -> 0
+    zodDefaultToZeroValue(0),
+  ]);
+}
+
+export function bigint(): z.ZodType<bigint, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.string().transform((x, ctx) => {
+      try {
+        return BigInt(x);
+      } catch (error) {
+        ctx.addIssue({
+          code: "invalid_type",
+          expected: "bigint",
+          received: "string",
+        });
+        return z.NEVER;
+      }
+    }),
+    zodDefaultToZeroValue(0n),
+  ]);
+}
+
+export function date(): z.ZodType<Date, z.ZodTypeDef, unknown> {
+  return z.union([
+    z.union([z.string(), zodDefaultToZeroValue(0)]).transform((x) =>
+      new Date(x)
+    ).pipe(z.date()),
+    z.number().transform((x, ctx) => {
+      const date = new Date(x);
+      if (isNaN(date.getTime())) {
+        ctx.addIssue({
+          code: "invalid_type",
+          expected: "date",
+          received: "number",
+        });
+        return z.NEVER;
+      }
+      return unrecognized(date);
+    }),
+  ]);
+}
+
+export function literal<T extends string | number | boolean>(
+  value: T,
+): z.ZodType<T, z.ZodTypeDef, unknown> {
+  return z.union([z.literal(value), zodDefaultToZeroValue(value)]);
+}
+
+export function literalBigInt<T extends bigint>(
+  value: T,
+): z.ZodType<T, z.ZodTypeDef, unknown> {
+  return z.literal(String(value)).transform((x) => BigInt(x)) as any;
+}
+
+export function optional<T extends z.ZodType>(t: T) {
+  return z.union([
+    z.undefined(),
+
+    // Null -> undefined
+    z.null().transform(() => unrecognized(undefined)),
+    t,
+  ]);
+}
+
+export function nullable<T extends z.ZodType>(t: T) {
+  return z.union([
+    z.null(),
+
+    // Undefined -> null
+    z.undefined().transform(() => defaultToZeroValue(null)),
+    t,
+  ]);
+}
+
+function zodDefaultToZeroValue<T>(
+  value: T,
+): z.ZodType<T, z.ZodTypeDef, unknown> {
+  return z.any().transform((input, ctx) => {
+    if (input === undefined) return defaultToZeroValue(value);
+    if (input === null) return defaultToZeroValue(value);
+    ctx.addIssue({
+      code: "invalid_type",
+      expected: "undefined",
+      received: "unknown",
+    });
+    return z.NEVER;
+  });
+}

package/src/types/smartUnion.ts

@@ -0,0 +1,153 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+// Not needed if lax mode
+import * as z from "zod/v3";
+import { startCountingDefaultToZeroValue } from "./defaultToZeroValue.js";
+import { RFCDate } from "./rfcdate.js";
+import { startCountingUnrecognized } from "./unrecognized.js";
+
+interface Candidate {
+  data: unknown;
+  /** Total number of fields in the parsed data */
+  fieldCount: number;
+  /** Number of fields which only matched due to lax parsing */
+  inexactCount: number;
+  /** Number of fields which defaulted to zero values */
+  zeroDefaultCount: number;
+}
+
+/**
+ * Smart union parser that tries all schemas and returns the best match
+ * based on the number of populated fields.
+ */
+export function smartUnion<
+  Options extends readonly [z.ZodType, z.ZodType, ...z.ZodType[]],
+>(
+  options: Options,
+): z.ZodType<
+  z.output<Options[number]>,
+  z.ZodTypeDef,
+  z.input<Options[number]>
+> {
+  return z.unknown().transform((input, ctx) => {
+    const candidates: Candidate[] = [];
+    const errors: z.ZodIssue[][] = options.map(() => []);
+
+    const parentUnrecognizedCtr = startCountingUnrecognized();
+    const parentZeroDefaultCtr = startCountingDefaultToZeroValue();
+
+    // Filter out invalid options
+    for (const [i, option] of options.entries()) {
+      const unrecognizedCtr = startCountingUnrecognized();
+      const zeroDefaultCtr = startCountingDefaultToZeroValue();
+      const result = option.safeParse(input);
+      const inexactCount = unrecognizedCtr.end();
+      const zeroDefaultCount = zeroDefaultCtr.end();
+      if (result.success) {
+        candidates.push({
+          data: result.data,
+          inexactCount,
+          zeroDefaultCount,
+          fieldCount: -1, // We'll count this later if needed
+        });
+        continue;
+      }
+      errors[i]!.push(...result.error.issues);
+    }
+
+    // No valid options
+    if (candidates.length === 0) {
+      parentUnrecognizedCtr.end(0);
+      parentZeroDefaultCtr.end(0);
+      ctx.addIssue({
+        code: "invalid_union",
+        unionErrors: errors.map(issues => new z.ZodError(issues)),
+      });
+      return z.NEVER;
+    }
+
+    let best = candidates[0]!;
+
+    // Find the best option
+    for (const candidate of candidates) {
+      // Minor optimization to avoid counting fields if there's only one candidate
+      if (candidates.length > 1) {
+        candidate.fieldCount = countFieldsRecursive(candidate.data);
+      }
+      best = better(candidate, best);
+    }
+
+    // The cost of this union should be the cost of the best candidate not all the candidates
+    parentUnrecognizedCtr.end(best.inexactCount);
+    parentZeroDefaultCtr.end(best.zeroDefaultCount);
+
+    return best.data;
+  }) as any;
+}
+
+function better(a: Candidate, b: Candidate): Candidate {
+  // First prefer exact matches over inexact ones
+  const aIsExact = a.inexactCount === 0;
+  const bIsExact = b.inexactCount === 0;
+  if (aIsExact !== bIsExact) {
+    return aIsExact ? a : b;
+  }
+
+  // Then compare field counts
+  const actualFieldCountA = a.fieldCount - a.zeroDefaultCount;
+  const actualFieldCountB = b.fieldCount - b.zeroDefaultCount;
+  if (actualFieldCountA !== actualFieldCountB) {
+    return actualFieldCountA > actualFieldCountB ? a : b;
+  }
+  return a.inexactCount < b.inexactCount ? a : b;
+}
+
+/**
+ * Counts the number of fields in a parsed value recursively.
+ * @param `parsed` assumed to *not* contain cycles
+ * fieldCount: total number of fields found
+ * inexactCount: number of primitive values that are not unrecognized enum values
+ */
+function countFieldsRecursive(parsed: unknown): number {
+  let fieldCount = 0;
+
+  const queue: unknown[] = [parsed];
+  let index = 0;
+
+  while (index < queue.length) {
+    const value = queue[index++];
+    if (value === undefined) {
+      continue;
+    }
+
+    // Check if it's a primitive value
+    const type = typeof value;
+    if (
+      value === null
+      || type === "number"
+      || type === "string"
+      || type === "boolean"
+      || type === "bigint"
+      || value instanceof Date
+      || value instanceof RFCDate
+    ) {
+      fieldCount++;
+      continue;
+    }
+
+    // Handle arrays
+    if (Array.isArray(value)) {
+      queue.push(...value);
+      continue;
+    }
+
+    // Handle objects
+    if (type === "object") {
+      queue.push(...Object.values(value));
+    }
+  }
+
+  return fieldCount;
+}

package/dist/commonjs/funcs/acceptanceTermsCreate.d.ts

@@ -1,17 +0,0 @@
-import { OatFiSDKCore } from "../core.js";
-import { RequestOptions } from "../lib/sdks.js";
-import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
-import { OatFiSDKError } from "../models/errors/oatfisdkerror.js";
-import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import * as models from "../models/index.js";
-import { APIPromise } from "../types/async.js";
-import { Result } from "../types/fp.js";
-/**
- * Create a new underwriting terms acceptance record
- *
- * @remarks
- * Creates a new agreement acceptance record. When a business entity accepts underwriting terms (via hosted flow or embedded component), a webhook event `agreement_acceptance.created` is automatically emitted to the partner's configured webhook endpoint. The event payload includes the business external ID, timestamp of acceptance, terms version identifier, and terms file URL.
- */
-export declare function acceptanceTermsCreate(client: OatFiSDKCore, request: models.CreateAgreementAcceptanceDto, options?: RequestOptions): APIPromise<Result<models.AgreementAcceptanceResponseDto, OatFiSDKError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
-//# sourceMappingURL=acceptanceTermsCreate.d.ts.map

package/dist/commonjs/models/acceptedvia.d.ts

@@ -1,19 +0,0 @@
-import * as z from "zod/v3";
-import { ClosedEnum } from "../types/enums.js";
-/**
- * How the terms were accepted
- */
-export declare const AcceptedVia: {
-    readonly Component: "COMPONENT";
-    readonly Hosted: "HOSTED";
-    readonly PartnerApi: "PARTNER_API";
-};
-/**
- * How the terms were accepted
- */
-export type AcceptedVia = ClosedEnum<typeof AcceptedVia>;
-/** @internal */
-export declare const AcceptedVia$inboundSchema: z.ZodNativeEnum<typeof AcceptedVia>;
-/** @internal */
-export declare const AcceptedVia$outboundSchema: z.ZodNativeEnum<typeof AcceptedVia>;
-//# sourceMappingURL=acceptedvia.d.ts.map

package/dist/commonjs/models/acceptedvia.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"acceptedvia.d.ts","sourceRoot":"","sources":["../../../src/models/acceptedvia.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,WAAW;;;;CAId,CAAC;AACX;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAEzD,gBAAgB;AAChB,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,aAAa,CAAC,OAAO,WAAW,CAChD,CAAC;AAC3B,gBAAgB;AAChB,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,aAAa,CAAC,OAAO,WAAW,CAChD,CAAC"}