@interfere/attio 0.1.3 → 0.2.1

package/src/models/operations/index.ts

@@ -5,8 +5,13 @@
 export * from "./delete-v2-comments-comment-id.js";
 export * from "./delete-v2-meetings-meeting-id-call-recordings-call-recording-id.js";
 export * from "./delete-v2-webhooks-webhook-id.js";
+export * from "./get-scim-v2-groups.js";
 export * from "./get-scim-v2-schemas.js";
+export * from "./get-scim-v2-users.js";
 export * from "./get-v2-comments-comment-id.js";
+export * from "./get-v2-files-file-id-download.js";
+export * from "./get-v2-files-file-id.js";
+export * from "./get-v2-files.js";
 export * from "./get-v2-lists-list-entries-entry-id-attributes-attribute-values-owner-actor-type.js";
 export * from "./get-v2-lists-list-entries-entry-id-attributes-attribute-values-response.js";
 export * from "./get-v2-lists.js";
@@ -33,7 +38,11 @@ export * from "./get-v2-workspace-members.js";
 export * from "./patch-v2-lists-list-entries-entry-id-entry-value-rating.js";
 export * from "./patch-v2-objects-object-records-record-id-bad-request-type.js";
 export * from "./patch-v2-tasks-task-id-response.js";
+export * from "./post-scim-v2-groups.js";
+export * from "./post-scim-v2-users.js";
 export * from "./post-v2-comments.js";
+export * from "./post-v2-files-upload.js";
+export * from "./post-v2-files.js";
 export * from "./post-v2-lists-list-entries.js";
 export * from "./post-v2-lists.js";
 export * from "./post-v2-meetings-meeting-id-call-recordings.js";
@@ -42,6 +51,6 @@ export * from "./post-v2-objects-object-records-query.js";
 export * from "./post-v2-objects-records-search.js";
 export * from "./post-v2-objects.js";
 export * from "./post-v2-target-identifier-attributes.js";
-export * from "./post-v2-tasks-data.js";
+export * from "./post-v2-tasks-assignee-workspace-member.js";
 export * from "./post-v2-webhooks.js";
 export * from "./put-v2-lists-list-entries.js";

package/src/models/operations/patch-v2-tasks-task-id-response.ts

@@ -11,10 +11,49 @@ import { smartUnion } from "../../types/smart-union.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 import {
-  PostV2TasksData,
-  PostV2TasksData$Outbound,
-  PostV2TasksData$outboundSchema,
-} from "./post-v2-tasks-data.js";
+  PostV2TasksAssignee,
+  PostV2TasksAssignee$Outbound,
+  PostV2TasksAssignee$outboundSchema,
+  PostV2TasksAssigneeWorkspaceMember,
+  PostV2TasksAssigneeWorkspaceMember$Outbound,
+  PostV2TasksAssigneeWorkspaceMember$outboundSchema,
+  PostV2TasksFormat,
+  PostV2TasksFormat$outboundSchema,
+  PostV2TasksLinkedRecordUnion,
+  PostV2TasksLinkedRecordUnion$Outbound,
+  PostV2TasksLinkedRecordUnion$outboundSchema,
+} from "./post-v2-tasks-assignee-workspace-member.js";
+
+export type PostV2TasksAssigneeUnion =
+  | PostV2TasksAssigneeWorkspaceMember
+  | PostV2TasksAssignee;
+
+export type PostV2TasksData = {
+  /**
+   * The text content of the task, in the format specified by the `format` property. A max length of 2000 characters is enforced.
+   */
+  content: string;
+  /**
+   * The format of the task content to be created. Rich text formatting, links and @references are not supported.
+   */
+  format: PostV2TasksFormat;
+  /**
+   * The deadline of the task, in ISO 8601 format.
+   */
+  deadlineAt: string | null;
+  /**
+   * Whether the task has been completed.
+   */
+  isCompleted: boolean;
+  /**
+   * Records linked to the task. Creating record links within task content text is not possible via the API at present.
+   */
+  linkedRecords: Array<PostV2TasksLinkedRecordUnion>;
+  /**
+   * Workspace members assigned to this task.
+   */
+  assignees: Array<PostV2TasksAssigneeWorkspaceMember | PostV2TasksAssignee>;
+};
 
 export type PostV2TasksRequest = {
   data: PostV2TasksData;
@@ -473,6 +512,73 @@ export type PatchV2TasksTaskIdResponse = {
   data: models.Task;
 };
 
+/** @internal */
+export type PostV2TasksAssigneeUnion$Outbound =
+  | PostV2TasksAssigneeWorkspaceMember$Outbound
+  | PostV2TasksAssignee$Outbound;
+
+/** @internal */
+export const PostV2TasksAssigneeUnion$outboundSchema: z.ZodMiniType<
+  PostV2TasksAssigneeUnion$Outbound,
+  PostV2TasksAssigneeUnion
+> = smartUnion([
+  PostV2TasksAssigneeWorkspaceMember$outboundSchema,
+  PostV2TasksAssignee$outboundSchema,
+]);
+
+export function postV2TasksAssigneeUnionToJSON(
+  postV2TasksAssigneeUnion: PostV2TasksAssigneeUnion,
+): string {
+  return JSON.stringify(
+    PostV2TasksAssigneeUnion$outboundSchema.parse(postV2TasksAssigneeUnion),
+  );
+}
+
+/** @internal */
+export type PostV2TasksData$Outbound = {
+  content: string;
+  format: string;
+  deadline_at: string | null;
+  is_completed: boolean;
+  linked_records: Array<PostV2TasksLinkedRecordUnion$Outbound>;
+  assignees: Array<
+    PostV2TasksAssigneeWorkspaceMember$Outbound | PostV2TasksAssignee$Outbound
+  >;
+};
+
+/** @internal */
+export const PostV2TasksData$outboundSchema: z.ZodMiniType<
+  PostV2TasksData$Outbound,
+  PostV2TasksData
+> = z.pipe(
+  z.object({
+    content: z.string(),
+    format: PostV2TasksFormat$outboundSchema,
+    deadlineAt: z.nullable(z.string()),
+    isCompleted: z.boolean(),
+    linkedRecords: z.array(PostV2TasksLinkedRecordUnion$outboundSchema),
+    assignees: z.array(
+      smartUnion([
+        PostV2TasksAssigneeWorkspaceMember$outboundSchema,
+        PostV2TasksAssignee$outboundSchema,
+      ]),
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      deadlineAt: "deadline_at",
+      isCompleted: "is_completed",
+      linkedRecords: "linked_records",
+    });
+  }),
+);
+
+export function postV2TasksDataToJSON(
+  postV2TasksData: PostV2TasksData,
+): string {
+  return JSON.stringify(PostV2TasksData$outboundSchema.parse(postV2TasksData));
+}
+
 /** @internal */
 export type PostV2TasksRequest$Outbound = {
   data: PostV2TasksData$Outbound;
@@ -483,7 +589,7 @@ export const PostV2TasksRequest$outboundSchema: z.ZodMiniType<
   PostV2TasksRequest$Outbound,
   PostV2TasksRequest
 > = z.object({
-  data: PostV2TasksData$outboundSchema,
+  data: z.lazy(() => PostV2TasksData$outboundSchema),
 });
 
 export function postV2TasksRequestToJSON(

package/src/models/operations/post-scim-v2-groups.ts

@@ -0,0 +1,99 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+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/sdk-validation-error.js";
+
+export type Member = {
+  value: string;
+  dollarRef: string;
+  display?: string | undefined;
+};
+
+export type PostScimV2GroupsMeta = {
+  resourceType: string;
+  created: string;
+  lastModified: string;
+};
+
+/**
+ * Created
+ */
+export type PostScimV2GroupsResponse = {
+  schemas: Array<string>;
+  id: string;
+  displayName: string;
+  members: Array<Member>;
+  meta: PostScimV2GroupsMeta;
+};
+
+/** @internal */
+export const Member$inboundSchema: z.ZodMiniType<Member, unknown> = z.pipe(
+  z.object({
+    value: types.string(),
+    $ref: types.string(),
+    display: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "$ref": "dollarRef",
+    });
+  }),
+);
+
+export function memberFromJSON(
+  jsonString: string,
+): SafeParseResult<Member, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Member$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Member' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostScimV2GroupsMeta$inboundSchema: z.ZodMiniType<
+  PostScimV2GroupsMeta,
+  unknown
+> = z.object({
+  resourceType: types.string(),
+  created: types.string(),
+  lastModified: types.string(),
+});
+
+export function postScimV2GroupsMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<PostScimV2GroupsMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostScimV2GroupsMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostScimV2GroupsMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostScimV2GroupsResponse$inboundSchema: z.ZodMiniType<
+  PostScimV2GroupsResponse,
+  unknown
+> = z.object({
+  schemas: z.array(types.string()),
+  id: types.string(),
+  displayName: types.string(),
+  members: z.array(z.lazy(() => Member$inboundSchema)),
+  meta: z.lazy(() => PostScimV2GroupsMeta$inboundSchema),
+});
+
+export function postScimV2GroupsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PostScimV2GroupsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostScimV2GroupsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostScimV2GroupsResponse' from JSON`,
+  );
+}

package/src/models/operations/post-scim-v2-users.ts

@@ -0,0 +1,141 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+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/sdk-validation-error.js";
+
+export type Name = {
+  givenName: string;
+  familyName: string;
+};
+
+export type Email = {
+  value: string;
+  primary: boolean;
+  type?: string | undefined;
+};
+
+export type Role = {
+  value: string;
+  primary: boolean;
+};
+
+export type PostScimV2UsersMeta = {
+  resourceType: string;
+  created: string;
+  lastModified: string;
+};
+
+/**
+ * Created
+ */
+export type PostScimV2UsersResponse = {
+  schemas: Array<string>;
+  id: string;
+  userName: string;
+  name: Name;
+  emails: Array<Email>;
+  roles: Array<Role>;
+  profileUrl?: string | undefined;
+  active: boolean;
+  meta: PostScimV2UsersMeta;
+};
+
+/** @internal */
+export const Name$inboundSchema: z.ZodMiniType<Name, unknown> = z.object({
+  givenName: types.string(),
+  familyName: types.string(),
+});
+
+export function nameFromJSON(
+  jsonString: string,
+): SafeParseResult<Name, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Name$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Name' from JSON`,
+  );
+}
+
+/** @internal */
+export const Email$inboundSchema: z.ZodMiniType<Email, unknown> = z.object({
+  value: types.string(),
+  primary: types.boolean(),
+  type: types.optional(types.string()),
+});
+
+export function emailFromJSON(
+  jsonString: string,
+): SafeParseResult<Email, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Email$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Email' from JSON`,
+  );
+}
+
+/** @internal */
+export const Role$inboundSchema: z.ZodMiniType<Role, unknown> = z.object({
+  value: types.string(),
+  primary: types.boolean(),
+});
+
+export function roleFromJSON(
+  jsonString: string,
+): SafeParseResult<Role, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Role$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Role' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostScimV2UsersMeta$inboundSchema: z.ZodMiniType<
+  PostScimV2UsersMeta,
+  unknown
+> = z.object({
+  resourceType: types.string(),
+  created: types.string(),
+  lastModified: types.string(),
+});
+
+export function postScimV2UsersMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<PostScimV2UsersMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostScimV2UsersMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostScimV2UsersMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostScimV2UsersResponse$inboundSchema: z.ZodMiniType<
+  PostScimV2UsersResponse,
+  unknown
+> = z.object({
+  schemas: z.array(types.string()),
+  id: types.string(),
+  userName: types.string(),
+  name: z.lazy(() => Name$inboundSchema),
+  emails: z.array(z.lazy(() => Email$inboundSchema)),
+  roles: z.array(z.lazy(() => Role$inboundSchema)),
+  profileUrl: types.optional(types.string()),
+  active: types.boolean(),
+  meta: z.lazy(() => PostScimV2UsersMeta$inboundSchema),
+});
+
+export function postScimV2UsersResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PostScimV2UsersResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostScimV2UsersResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostScimV2UsersResponse' from JSON`,
+  );
+}

package/src/models/operations/post-v2-files-upload.ts

@@ -0,0 +1,117 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { blobLikeSchema } from "../../types/blobs.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+
+export type FileT = {
+  fileName: string;
+  content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
+};
+
+export type PostV2FilesUploadRequest = {
+  /**
+   * The file to upload.
+   */
+  file: FileT | Blob;
+  /**
+   * The object slug or ID.
+   */
+  object: string;
+  /**
+   * The ID of the record to upload the file to.
+   */
+  recordId: string;
+  /**
+   * Optional parent folder ID. Omit to upload to the root folder.
+   */
+  parentFolderId?: string | undefined;
+};
+
+/**
+ * Created
+ */
+export type PostV2FilesUploadResponse = {
+  data: models.FileT;
+};
+
+/** @internal */
+export type FileT$Outbound = {
+  fileName: string;
+  content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
+};
+
+/** @internal */
+export const FileT$outboundSchema: z.ZodMiniType<FileT$Outbound, FileT> = z
+  .object({
+    fileName: z.string(),
+    content: z.union([
+      z.custom<ReadableStream<Uint8Array>>(x => x instanceof ReadableStream),
+      z.custom<Blob>(x => x instanceof Blob),
+      z.custom<ArrayBuffer>(x => x instanceof ArrayBuffer),
+      z.custom<Uint8Array>(x => x instanceof Uint8Array),
+    ]),
+  });
+
+export function fileToJSON(fileT: FileT): string {
+  return JSON.stringify(FileT$outboundSchema.parse(fileT));
+}
+
+/** @internal */
+export type PostV2FilesUploadRequest$Outbound = {
+  file: FileT$Outbound | Blob;
+  object: string;
+  record_id: string;
+  parent_folder_id?: string | undefined;
+};
+
+/** @internal */
+export const PostV2FilesUploadRequest$outboundSchema: z.ZodMiniType<
+  PostV2FilesUploadRequest$Outbound,
+  PostV2FilesUploadRequest
+> = z.pipe(
+  z.object({
+    file: z.union([z.lazy(() => FileT$outboundSchema), blobLikeSchema]),
+    object: z.string(),
+    recordId: z.string(),
+    parentFolderId: z.optional(z.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      recordId: "record_id",
+      parentFolderId: "parent_folder_id",
+    });
+  }),
+);
+
+export function postV2FilesUploadRequestToJSON(
+  postV2FilesUploadRequest: PostV2FilesUploadRequest,
+): string {
+  return JSON.stringify(
+    PostV2FilesUploadRequest$outboundSchema.parse(postV2FilesUploadRequest),
+  );
+}
+
+/** @internal */
+export const PostV2FilesUploadResponse$inboundSchema: z.ZodMiniType<
+  PostV2FilesUploadResponse,
+  unknown
+> = z.object({
+  data: models.FileT$inboundSchema,
+});
+
+export function postV2FilesUploadResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PostV2FilesUploadResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostV2FilesUploadResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostV2FilesUploadResponse' from JSON`,
+  );
+}