@dockflow/sdk 0.2.0 → 0.3.0

package/src/apis/{V3DownstreamApi.ts → TradeflowsApi.ts}

@@ -13,18 +13,25 @@
  */
 
 import * as runtime from '../runtime';
+import {
+    type CreateTradeflows202Response,
+    CreateTradeflows202ResponseFromJSON,
+    CreateTradeflows202ResponseToJSON,
+} from '../models/CreateTradeflows202Response';
 import {
     type DownstreamTradeflow,
     DownstreamTradeflowFromJSON,
     DownstreamTradeflowToJSON,
 } from '../models/DownstreamTradeflow';
-import {
-    type V3DownstreamPost202Response,
-    V3DownstreamPost202ResponseFromJSON,
-    V3DownstreamPost202ResponseToJSON,
-} from '../models/V3DownstreamPost202Response';
 
-export interface V3DownstreamDeleteRequest {
+export interface CreateTradeflowsRequest {
+    /**
+     * 
+     */
+    downstreamTradeflow: Array<DownstreamTradeflow>;
+}
+
+export interface DeleteTradeflowRequest {
     /**
      * 
      */
@@ -39,41 +46,28 @@ export interface V3DownstreamDeleteRequest {
     hard?: boolean;
 }
 
-export interface V3DownstreamPostRequest {
-    /**
-     * 
-     */
-    downstreamTradeflow: Array<DownstreamTradeflow>;
-}
-
 /**
  * 
  */
-export class V3DownstreamApi extends runtime.BaseAPI {
+export class TradeflowsApi extends runtime.BaseAPI {
 
     /**
-     * Creates request options for v3DownstreamDelete without sending the request
+     * Creates request options for createTradeflows without sending the request
      */
-    async v3DownstreamDeleteRequestOpts(requestParameters: V3DownstreamDeleteRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['tradeflowReference'] == null) {
+    async createTradeflowsRequestOpts(requestParameters: CreateTradeflowsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['downstreamTradeflow'] == null) {
             throw new runtime.RequiredError(
-                'tradeflowReference',
-                'Required parameter "tradeflowReference" was null or undefined when calling v3DownstreamDelete().'
+                'downstreamTradeflow',
+                'Required parameter "downstreamTradeflow" was null or undefined when calling createTradeflows().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['confirm'] != null) {
-            queryParameters['confirm'] = requestParameters['confirm'];
-        }
-
-        if (requestParameters['hard'] != null) {
-            queryParameters['hard'] = requestParameters['hard'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("ApiKey", []);
@@ -83,55 +77,57 @@ export class V3DownstreamApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/v3/downstream/tradeflows/{tradeflow_reference}`;
-        urlPath = urlPath.replace('{tradeflow_reference}', encodeURIComponent(String(requestParameters['tradeflowReference'])));
+        let urlPath = `/v3/downstream/tradeflows`;
 
         return {
             path: urlPath,
-            method: 'DELETE',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: requestParameters['downstreamTradeflow']!.map(DownstreamTradeflowToJSON),
         };
     }
 
     /**
-     * Delete a tradeflow
+     * Upsert tradeflows
      */
-    async v3DownstreamDeleteRaw(requestParameters: V3DownstreamDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
-        const requestOptions = await this.v3DownstreamDeleteRequestOpts(requestParameters);
+    async createTradeflowsRaw(requestParameters: CreateTradeflowsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateTradeflows202Response>> {
+        const requestOptions = await this.createTradeflowsRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        if (this.isJsonMime(response.headers.get('content-type'))) {
-            return new runtime.JSONApiResponse<string>(response);
-        } else {
-            return new runtime.TextApiResponse(response) as any;
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => CreateTradeflows202ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Delete a tradeflow
+     * Upsert tradeflows
      */
-    async v3DownstreamDelete(requestParameters: V3DownstreamDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
-        const response = await this.v3DownstreamDeleteRaw(requestParameters, initOverrides);
+    async createTradeflows(requestParameters: CreateTradeflowsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateTradeflows202Response> {
+        const response = await this.createTradeflowsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for v3DownstreamPost without sending the request
+     * Creates request options for deleteTradeflow without sending the request
      */
-    async v3DownstreamPostRequestOpts(requestParameters: V3DownstreamPostRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['downstreamTradeflow'] == null) {
+    async deleteTradeflowRequestOpts(requestParameters: DeleteTradeflowRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['tradeflowReference'] == null) {
             throw new runtime.RequiredError(
-                'downstreamTradeflow',
-                'Required parameter "downstreamTradeflow" was null or undefined when calling v3DownstreamPost().'
+                'tradeflowReference',
+                'Required parameter "tradeflowReference" was null or undefined when calling deleteTradeflow().'
             );
         }
 
         const queryParameters: any = {};
 
-        const headerParameters: runtime.HTTPHeaders = {};
+        if (requestParameters['confirm'] != null) {
+            queryParameters['confirm'] = requestParameters['confirm'];
+        }
 
-        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['hard'] != null) {
+            queryParameters['hard'] = requestParameters['hard'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
@@ -142,32 +138,36 @@ export class V3DownstreamApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/v3/downstream/tradeflows`;
+        let urlPath = `/v3/downstream/tradeflows/{tradeflow_reference}`;
+        urlPath = urlPath.replace('{tradeflow_reference}', encodeURIComponent(String(requestParameters['tradeflowReference'])));
 
         return {
             path: urlPath,
-            method: 'POST',
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters['downstreamTradeflow']!.map(DownstreamTradeflowToJSON),
         };
     }
 
     /**
-     * Upsert tradeflows
+     * Delete a tradeflow
      */
-    async v3DownstreamPostRaw(requestParameters: V3DownstreamPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<V3DownstreamPost202Response>> {
-        const requestOptions = await this.v3DownstreamPostRequestOpts(requestParameters);
+    async deleteTradeflowRaw(requestParameters: DeleteTradeflowRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+        const requestOptions = await this.deleteTradeflowRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => V3DownstreamPost202ResponseFromJSON(jsonValue));
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
-     * Upsert tradeflows
+     * Delete a tradeflow
      */
-    async v3DownstreamPost(requestParameters: V3DownstreamPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<V3DownstreamPost202Response> {
-        const response = await this.v3DownstreamPostRaw(requestParameters, initOverrides);
+    async deleteTradeflow(requestParameters: DeleteTradeflowRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.deleteTradeflowRaw(requestParameters, initOverrides);
         return await response.value();
     }
 

package/src/apis/{V3UpstreamApi.ts → UpstreamApi.ts}

@@ -14,17 +14,17 @@
 
 import * as runtime from '../runtime';
 import {
-    type V3UpstreamGet200Response,
-    V3UpstreamGet200ResponseFromJSON,
-    V3UpstreamGet200ResponseToJSON,
-} from '../models/V3UpstreamGet200Response';
+    type GetUpstream200Response,
+    GetUpstream200ResponseFromJSON,
+    GetUpstream200ResponseToJSON,
+} from '../models/GetUpstream200Response';
 import {
-    type V3UpstreamGet400Response,
-    V3UpstreamGet400ResponseFromJSON,
-    V3UpstreamGet400ResponseToJSON,
-} from '../models/V3UpstreamGet400Response';
+    type GetUpstream400Response,
+    GetUpstream400ResponseFromJSON,
+    GetUpstream400ResponseToJSON,
+} from '../models/GetUpstream400Response';
 
-export interface V3UpstreamGetRequest {
+export interface GetUpstreamRequest {
     /**
      * Only tradeflows changed after this ISO 8601 timestamp (exclusive), with an offset. Without since, cursor, tradeflow or container: the last 15 minutes.
      */
@@ -60,7 +60,7 @@ export interface V3UpstreamGetRequest {
     /**
      * Shape of `events`: `v3` (Dockflow milestones) or `dcsa-tnt-2.2` (DCSA Track & Trace 2.2). The rest of the record is identical.
      */
-    format?: V3UpstreamGetFormatEnum;
+    format?: GetUpstreamFormatEnum;
     /**
      * Tradeflows per page, 1 to 1000. Default 50.
      */
@@ -68,18 +68,18 @@ export interface V3UpstreamGetRequest {
     /**
      * Set to 1 and Dockflow keeps your position per API key and filter set, so repeated identical polls skip nothing.
      */
-    failsafe?: V3UpstreamGetFailsafeEnum;
+    failsafe?: GetUpstreamFailsafeEnum;
 }
 
 /**
  * 
  */
-export class V3UpstreamApi extends runtime.BaseAPI {
+export class UpstreamApi extends runtime.BaseAPI {
 
     /**
-     * Creates request options for v3UpstreamGet without sending the request
+     * Creates request options for getUpstream without sending the request
      */
-    async v3UpstreamGetRequestOpts(requestParameters: V3UpstreamGetRequest): Promise<runtime.RequestOpts> {
+    async getUpstreamRequestOpts(requestParameters: GetUpstreamRequest): Promise<runtime.RequestOpts> {
         const queryParameters: any = {};
 
         if (requestParameters['since'] != null) {
@@ -150,18 +150,18 @@ export class V3UpstreamApi extends runtime.BaseAPI {
     /**
      * Poll upstream events
      */
-    async v3UpstreamGetRaw(requestParameters: V3UpstreamGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<V3UpstreamGet200Response>> {
-        const requestOptions = await this.v3UpstreamGetRequestOpts(requestParameters);
+    async getUpstreamRaw(requestParameters: GetUpstreamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetUpstream200Response>> {
+        const requestOptions = await this.getUpstreamRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => V3UpstreamGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetUpstream200ResponseFromJSON(jsonValue));
     }
 
     /**
      * Poll upstream events
      */
-    async v3UpstreamGet(requestParameters: V3UpstreamGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<V3UpstreamGet200Response> {
-        const response = await this.v3UpstreamGetRaw(requestParameters, initOverrides);
+    async getUpstream(requestParameters: GetUpstreamRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetUpstream200Response> {
+        const response = await this.getUpstreamRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -170,16 +170,16 @@ export class V3UpstreamApi extends runtime.BaseAPI {
 /**
  * @export
  */
-export const V3UpstreamGetFormatEnum = {
+export const GetUpstreamFormatEnum = {
     V3: 'v3',
     DcsaTnt22: 'dcsa-tnt-2.2',
 } as const;
-export type V3UpstreamGetFormatEnum = typeof V3UpstreamGetFormatEnum[keyof typeof V3UpstreamGetFormatEnum];
+export type GetUpstreamFormatEnum = typeof GetUpstreamFormatEnum[keyof typeof GetUpstreamFormatEnum];
 /**
  * @export
  */
-export const V3UpstreamGetFailsafeEnum = {
+export const GetUpstreamFailsafeEnum = {
     _0: '0',
     _1: '1',
 } as const;
-export type V3UpstreamGetFailsafeEnum = typeof V3UpstreamGetFailsafeEnum[keyof typeof V3UpstreamGetFailsafeEnum];
+export type GetUpstreamFailsafeEnum = typeof GetUpstreamFailsafeEnum[keyof typeof GetUpstreamFailsafeEnum];

package/src/apis/index.ts

@@ -1,6 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
-export * from './V3DocumentApi';
-export * from './V3DownstreamApi';
-export * from './V3UpstreamApi';
+export * from './DocumentsApi';
+export * from './TradeflowsApi';
+export * from './UpstreamApi';
 export * from './WidgetApi';

package/src/models/CreateTradeflows202Response.ts

@@ -0,0 +1,91 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Dockflow v3 API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 3.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { CreateTradeflows202ResponseTradeflowsInner } from './CreateTradeflows202ResponseTradeflowsInner';
+import {
+    CreateTradeflows202ResponseTradeflowsInnerFromJSON,
+    CreateTradeflows202ResponseTradeflowsInnerFromJSONTyped,
+    CreateTradeflows202ResponseTradeflowsInnerToJSON,
+    CreateTradeflows202ResponseTradeflowsInnerToJSONTyped,
+} from './CreateTradeflows202ResponseTradeflowsInner';
+
+/**
+ * 
+ * @export
+ * @interface CreateTradeflows202Response
+ */
+export interface CreateTradeflows202Response {
+    /**
+     * 
+     */
+    status: CreateTradeflows202ResponseStatusEnum;
+    /**
+     * 
+     */
+    tradeflows: Array<CreateTradeflows202ResponseTradeflowsInner>;
+}
+
+
+/**
+ * @export
+ */
+export const CreateTradeflows202ResponseStatusEnum = {
+    Queued: 'queued',
+} as const;
+export type CreateTradeflows202ResponseStatusEnum = typeof CreateTradeflows202ResponseStatusEnum[keyof typeof CreateTradeflows202ResponseStatusEnum];
+
+
+/**
+ * Check if a given object implements the CreateTradeflows202Response interface.
+ */
+export function instanceOfCreateTradeflows202Response(value: object): value is CreateTradeflows202Response {
+    if (!('status' in value) || value['status'] === undefined) return false;
+    if (value['status'] !== 'queued') return false;
+    
+    if (!('tradeflows' in value) || value['tradeflows'] === undefined) return false;
+    return true;
+}
+
+export function CreateTradeflows202ResponseFromJSON(json: any): CreateTradeflows202Response {
+    return CreateTradeflows202ResponseFromJSONTyped(json, false);
+}
+
+export function CreateTradeflows202ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): CreateTradeflows202Response {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'status': json['status'],
+        'tradeflows': ((json['tradeflows'] as Array<any>).map(CreateTradeflows202ResponseTradeflowsInnerFromJSON)),
+    };
+}
+
+export function CreateTradeflows202ResponseToJSON(json: any): CreateTradeflows202Response {
+    return CreateTradeflows202ResponseToJSONTyped(json, false);
+}
+
+export function CreateTradeflows202ResponseToJSONTyped(value?: CreateTradeflows202Response | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'status': value['status'],
+        'tradeflows': ((value['tradeflows'] as Array<any>).map(CreateTradeflows202ResponseTradeflowsInnerToJSON)),
+    };
+}
+

package/src/models/{V3DownstreamPost202ResponseTradeflowsInner.ts → CreateTradeflows202ResponseTradeflowsInner.ts}

@@ -16,9 +16,9 @@ import { mapValues } from '../runtime';
 /**
  * 
  * @export
- * @interface V3DownstreamPost202ResponseTradeflowsInner
+ * @interface CreateTradeflows202ResponseTradeflowsInner
  */
-export interface V3DownstreamPost202ResponseTradeflowsInner {
+export interface CreateTradeflows202ResponseTradeflowsInner {
     /**
      * 
      */
@@ -30,19 +30,19 @@ export interface V3DownstreamPost202ResponseTradeflowsInner {
 }
 
 /**
- * Check if a given object implements the V3DownstreamPost202ResponseTradeflowsInner interface.
+ * Check if a given object implements the CreateTradeflows202ResponseTradeflowsInner interface.
  */
-export function instanceOfV3DownstreamPost202ResponseTradeflowsInner(value: object): value is V3DownstreamPost202ResponseTradeflowsInner {
+export function instanceOfCreateTradeflows202ResponseTradeflowsInner(value: object): value is CreateTradeflows202ResponseTradeflowsInner {
     if ((!('tradeflowReference' in (value as Record<string, any>)) && !('tradeflow_reference' in (value as Record<string, any>))) || ((value as Record<string, any>)['tradeflowReference'] === undefined && (value as Record<string, any>)['tradeflow_reference'] === undefined)) return false;
     if (!('warnings' in value) || value['warnings'] === undefined) return false;
     return true;
 }
 
-export function V3DownstreamPost202ResponseTradeflowsInnerFromJSON(json: any): V3DownstreamPost202ResponseTradeflowsInner {
-    return V3DownstreamPost202ResponseTradeflowsInnerFromJSONTyped(json, false);
+export function CreateTradeflows202ResponseTradeflowsInnerFromJSON(json: any): CreateTradeflows202ResponseTradeflowsInner {
+    return CreateTradeflows202ResponseTradeflowsInnerFromJSONTyped(json, false);
 }
 
-export function V3DownstreamPost202ResponseTradeflowsInnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): V3DownstreamPost202ResponseTradeflowsInner {
+export function CreateTradeflows202ResponseTradeflowsInnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): CreateTradeflows202ResponseTradeflowsInner {
     if (json == null) {
         return json;
     }
@@ -53,11 +53,11 @@ export function V3DownstreamPost202ResponseTradeflowsInnerFromJSONTyped(json: an
     };
 }
 
-export function V3DownstreamPost202ResponseTradeflowsInnerToJSON(json: any): V3DownstreamPost202ResponseTradeflowsInner {
-    return V3DownstreamPost202ResponseTradeflowsInnerToJSONTyped(json, false);
+export function CreateTradeflows202ResponseTradeflowsInnerToJSON(json: any): CreateTradeflows202ResponseTradeflowsInner {
+    return CreateTradeflows202ResponseTradeflowsInnerToJSONTyped(json, false);
 }
 
-export function V3DownstreamPost202ResponseTradeflowsInnerToJSONTyped(value?: V3DownstreamPost202ResponseTradeflowsInner | null, ignoreDiscriminator: boolean = false): any {
+export function CreateTradeflows202ResponseTradeflowsInnerToJSONTyped(value?: CreateTradeflows202ResponseTradeflowsInner | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }

package/src/models/{V3DocumentGet200Response.ts → GetDocument200Response.ts}

@@ -13,24 +13,24 @@
  */
 
 import { mapValues } from '../runtime';
-import type { V3DocumentGet200ResponseDataInner } from './V3DocumentGet200ResponseDataInner';
+import type { GetDocument200ResponseDataInner } from './GetDocument200ResponseDataInner';
 import {
-    V3DocumentGet200ResponseDataInnerFromJSON,
-    V3DocumentGet200ResponseDataInnerFromJSONTyped,
-    V3DocumentGet200ResponseDataInnerToJSON,
-    V3DocumentGet200ResponseDataInnerToJSONTyped,
-} from './V3DocumentGet200ResponseDataInner';
+    GetDocument200ResponseDataInnerFromJSON,
+    GetDocument200ResponseDataInnerFromJSONTyped,
+    GetDocument200ResponseDataInnerToJSON,
+    GetDocument200ResponseDataInnerToJSONTyped,
+} from './GetDocument200ResponseDataInner';
 
 /**
  * 
  * @export
- * @interface V3DocumentGet200Response
+ * @interface GetDocument200Response
  */
-export interface V3DocumentGet200Response {
+export interface GetDocument200Response {
     /**
      * 
      */
-    data: Array<V3DocumentGet200ResponseDataInner>;
+    data: Array<GetDocument200ResponseDataInner>;
     /**
      * 
      */
@@ -42,43 +42,43 @@ export interface V3DocumentGet200Response {
 }
 
 /**
- * Check if a given object implements the V3DocumentGet200Response interface.
+ * Check if a given object implements the GetDocument200Response interface.
  */
-export function instanceOfV3DocumentGet200Response(value: object): value is V3DocumentGet200Response {
+export function instanceOfGetDocument200Response(value: object): value is GetDocument200Response {
     if (!('data' in value) || value['data'] === undefined) return false;
     if ((!('tradeflowReference' in (value as Record<string, any>)) && !('tradeflow_reference' in (value as Record<string, any>))) || ((value as Record<string, any>)['tradeflowReference'] === undefined && (value as Record<string, any>)['tradeflow_reference'] === undefined)) return false;
     if (!('count' in value) || value['count'] === undefined) return false;
     return true;
 }
 
-export function V3DocumentGet200ResponseFromJSON(json: any): V3DocumentGet200Response {
-    return V3DocumentGet200ResponseFromJSONTyped(json, false);
+export function GetDocument200ResponseFromJSON(json: any): GetDocument200Response {
+    return GetDocument200ResponseFromJSONTyped(json, false);
 }
 
-export function V3DocumentGet200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): V3DocumentGet200Response {
+export function GetDocument200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): GetDocument200Response {
     if (json == null) {
         return json;
     }
     return {
         
-        'data': ((json['data'] as Array<any>).map(V3DocumentGet200ResponseDataInnerFromJSON)),
+        'data': ((json['data'] as Array<any>).map(GetDocument200ResponseDataInnerFromJSON)),
         'tradeflowReference': json['tradeflow_reference'],
         'count': json['count'],
     };
 }
 
-export function V3DocumentGet200ResponseToJSON(json: any): V3DocumentGet200Response {
-    return V3DocumentGet200ResponseToJSONTyped(json, false);
+export function GetDocument200ResponseToJSON(json: any): GetDocument200Response {
+    return GetDocument200ResponseToJSONTyped(json, false);
 }
 
-export function V3DocumentGet200ResponseToJSONTyped(value?: V3DocumentGet200Response | null, ignoreDiscriminator: boolean = false): any {
+export function GetDocument200ResponseToJSONTyped(value?: GetDocument200Response | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
 
     return {
         
-        'data': ((value['data'] as Array<any>).map(V3DocumentGet200ResponseDataInnerToJSON)),
+        'data': ((value['data'] as Array<any>).map(GetDocument200ResponseDataInnerToJSON)),
         'tradeflow_reference': value['tradeflowReference'],
         'count': value['count'],
     };

package/src/models/{V3DocumentGet200ResponseDataInner.ts → GetDocument200ResponseDataInner.ts}

@@ -13,20 +13,20 @@
  */
 
 import { mapValues } from '../runtime';
-import type { V3DocumentGet200ResponseDataInnerDocumentType } from './V3DocumentGet200ResponseDataInnerDocumentType';
+import type { GetDocument200ResponseDataInnerDocumentType } from './GetDocument200ResponseDataInnerDocumentType';
 import {
-    V3DocumentGet200ResponseDataInnerDocumentTypeFromJSON,
-    V3DocumentGet200ResponseDataInnerDocumentTypeFromJSONTyped,
-    V3DocumentGet200ResponseDataInnerDocumentTypeToJSON,
-    V3DocumentGet200ResponseDataInnerDocumentTypeToJSONTyped,
-} from './V3DocumentGet200ResponseDataInnerDocumentType';
+    GetDocument200ResponseDataInnerDocumentTypeFromJSON,
+    GetDocument200ResponseDataInnerDocumentTypeFromJSONTyped,
+    GetDocument200ResponseDataInnerDocumentTypeToJSON,
+    GetDocument200ResponseDataInnerDocumentTypeToJSONTyped,
+} from './GetDocument200ResponseDataInnerDocumentType';
 
 /**
  * 
  * @export
- * @interface V3DocumentGet200ResponseDataInner
+ * @interface GetDocument200ResponseDataInner
  */
-export interface V3DocumentGet200ResponseDataInner {
+export interface GetDocument200ResponseDataInner {
     /**
      * 
      */
@@ -50,7 +50,7 @@ export interface V3DocumentGet200ResponseDataInner {
     /**
      * 
      */
-    documentType: V3DocumentGet200ResponseDataInnerDocumentType | null;
+    documentType: GetDocument200ResponseDataInnerDocumentType | null;
     /**
      * 
      */
@@ -66,9 +66,9 @@ export interface V3DocumentGet200ResponseDataInner {
 }
 
 /**
- * Check if a given object implements the V3DocumentGet200ResponseDataInner interface.
+ * Check if a given object implements the GetDocument200ResponseDataInner interface.
  */
-export function instanceOfV3DocumentGet200ResponseDataInner(value: object): value is V3DocumentGet200ResponseDataInner {
+export function instanceOfGetDocument200ResponseDataInner(value: object): value is GetDocument200ResponseDataInner {
     if (!('id' in value) || value['id'] === undefined) return false;
     if (!('name' in value) || value['name'] === undefined) return false;
     if (!('filetype' in value) || value['filetype'] === undefined) return false;
@@ -81,11 +81,11 @@ export function instanceOfV3DocumentGet200ResponseDataInner(value: object): valu
     return true;
 }
 
-export function V3DocumentGet200ResponseDataInnerFromJSON(json: any): V3DocumentGet200ResponseDataInner {
-    return V3DocumentGet200ResponseDataInnerFromJSONTyped(json, false);
+export function GetDocument200ResponseDataInnerFromJSON(json: any): GetDocument200ResponseDataInner {
+    return GetDocument200ResponseDataInnerFromJSONTyped(json, false);
 }
 
-export function V3DocumentGet200ResponseDataInnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): V3DocumentGet200ResponseDataInner {
+export function GetDocument200ResponseDataInnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): GetDocument200ResponseDataInner {
     if (json == null) {
         return json;
     }
@@ -96,18 +96,18 @@ export function V3DocumentGet200ResponseDataInnerFromJSONTyped(json: any, ignore
         'filetype': json['filetype'],
         'inputName': json['input_name'],
         'version': json['version'],
-        'documentType': V3DocumentGet200ResponseDataInnerDocumentTypeFromJSON(json['document_type']),
+        'documentType': GetDocument200ResponseDataInnerDocumentTypeFromJSON(json['document_type']),
         'metadata': json['metadata'],
         'createdAt': json['created_at'],
         'updatedAt': json['updated_at'],
     };
 }
 
-export function V3DocumentGet200ResponseDataInnerToJSON(json: any): V3DocumentGet200ResponseDataInner {
-    return V3DocumentGet200ResponseDataInnerToJSONTyped(json, false);
+export function GetDocument200ResponseDataInnerToJSON(json: any): GetDocument200ResponseDataInner {
+    return GetDocument200ResponseDataInnerToJSONTyped(json, false);
 }
 
-export function V3DocumentGet200ResponseDataInnerToJSONTyped(value?: V3DocumentGet200ResponseDataInner | null, ignoreDiscriminator: boolean = false): any {
+export function GetDocument200ResponseDataInnerToJSONTyped(value?: GetDocument200ResponseDataInner | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
@@ -119,7 +119,7 @@ export function V3DocumentGet200ResponseDataInnerToJSONTyped(value?: V3DocumentG
         'filetype': value['filetype'],
         'input_name': value['inputName'],
         'version': value['version'],
-        'document_type': V3DocumentGet200ResponseDataInnerDocumentTypeToJSON(value['documentType']),
+        'document_type': GetDocument200ResponseDataInnerDocumentTypeToJSON(value['documentType']),
         'metadata': value['metadata'],
         'created_at': value['createdAt'],
         'updated_at': value['updatedAt'],