NiuClient

Generated from the checked-in source. Do not edit this reference by hand.

SDK source. All SDK types.

Constructor and members

constructor

TypeScript

constructor(options: NiuClientOptions);

getPublicBranding

TypeScript

/** Public branding projection; the regular client credential does not expand it. */
getPublicBranding(options?: RequestOptions): Promise<import('./admin.js').BrandingConfiguration>;

getKey

TypeScript

/** Inspect the current API key's label, model grants, limits, and 60s usage window. */
getKey(options?: RequestOptions): Promise<{
    data: KeyIntrospection;
}>;

getGeneration

TypeScript

/** Retrieve token breakdown, timings, and customer charge for one generation attempt. */
getGeneration(id: string, options?: RequestOptions): Promise<{
    data: GenerationView;
}>;

imageSources

TypeScript

readonly imageSources: {
    prepare: (input: {
        image: string;
        valid_for_seconds: number;
    }, options?: RequestOptions) => Promise<{
        data: {
            source_id: string;
            retained: true;
            retention_seconds: number;
        };
    }>;
    erase: (id: string, options?: RequestOptions) => Promise<void>;
};

imageIngestions

TypeScript

readonly imageIngestions: {
    list: (query?: {
        before?: string;
    }, options?: RequestOptions) => Promise<{
        data: ImageIngestionConsentStatus[];
        next_cursor: string | null;
    }>;
    readiness: {
        refresh: (id: string, readId: string, options?: RequestOptions) => Promise<{
            data: ImageReadinessObservation;
        }>;
        retrieve: (id: string, readId: string, options?: RequestOptions) => Promise<{
            data: ImageReadinessObservation;
        }>;
    };
    dispatch: (id: string, options?: RequestOptions) => Promise<{
        data: ImageIngestionConsentStatus;
    }>;
    prepare: (id: string, input: ImageIngestionConsentInput, options?: RequestOptions) => Promise<{
        data: ImageIngestionConsentStatus;
    }>;
    retrieve: (id: string, options?: RequestOptions) => Promise<{
        data: ImageIngestionConsentStatus;
    }>;
    revoke: (id: string, options?: RequestOptions) => Promise<void>;
};

media

TypeScript

media: {
    capabilities: (model?: string, options?: RequestOptions) => Promise<import("./provider-capabilities.js").NativeProviderCapabilities>;
    verification: {
        create: (input: import("./media-verification.js").MediaVerificationInput, options?: import("./media-assets.js").MediaAssetMutationOptions) => Promise<{
            data: import("./media-verification.js").MediaVerificationSession;
        }>;
        list: (input: {
            model: string;
            after?: string;
            limit?: number;
        }, options?: RequestOptions) => Promise<{
            data: import("./media-verification.js").MediaVerificationSession[];
            next_cursor: string | null;
        }>;
        retrieve: (id: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-verification.js").MediaVerificationSession;
        }>;
        link: (id: string, model: string, options?: RequestOptions) => Promise<import("./media-verification.js").MediaVerificationLink>;
        refresh: (id: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-verification.js").MediaVerificationSession;
        }>;
    };
    groups: {
        list: (input: {
            model: string;
            after?: string;
            limit?: number;
        }, options?: RequestOptions) => Promise<import("./media-assets.js").MediaAssetPage<import("./media-assets.js").MediaAssetGroup>>;
        create: (input: {
            model: string;
            name: string;
            description?: string;
        }, options?: import("./media-assets.js").MediaAssetMutationOptions) => Promise<import("./media-assets.js").MediaAssetMutation>;
        retrieve: (id: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-assets.js").MediaAssetGroup;
        }>;
        update: (id: string, input: {
            model: string;
            name?: string;
            description?: string;
            expected_revision?: string;
        }, options?: import("./media-assets.js").MediaAssetMutationOptions) => Promise<import("./media-assets.js").MediaAssetMutation>;
        delete: (id: string, input: {
            model: string;
            expected_revision?: string;
        }, options?: import("./media-assets.js").MediaAssetMutationOptions) => Promise<import("./media-assets.js").MediaAssetMutation>;
        refresh: (id: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-assets.js").MediaAssetGroup;
        }>;
    };
    assets: {
        list: (input: {
            model: string;
            after?: string;
            limit?: number;
        } & {
            group_id?: string;
        }, options?: RequestOptions) => Promise<import("./media-assets.js").MediaAssetPage<import("./media-assets.js").MediaAsset>>;
        create: (input: {
            model: string;
            group_id: string;
            url: string;
            name?: string;
            kind: "image" | "video" | "audio";
        }, options?: import("./media-assets.js").MediaAssetMutationOptions) => Promise<import("./media-assets.js").MediaAssetMutation>;
        retrieve: (id: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-assets.js").MediaAsset;
        }>;
        update: (id: string, input: {
            model: string;
            name: string;
            expected_revision?: string;
        }, options?: import("./media-assets.js").MediaAssetMutationOptions) => Promise<import("./media-assets.js").MediaAssetMutation>;
        delete: (id: string, input: {
            model: string;
            expected_revision?: string;
        }, options?: import("./media-assets.js").MediaAssetMutationOptions) => Promise<import("./media-assets.js").MediaAssetMutation>;
        refresh: (id: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-assets.js").MediaAsset;
        }>;
    };
    operations: {
        prepare: (input: import("./media-assets.js").MediaAssetOperationInput, options: import("./media-assets.js").MediaAssetPreparationOptions) => Promise<import("./media-assets.js").MediaAssetMutation>;
        dispatch: (id: string, input: import("./media-assets.js").MediaAssetOperationInput, options: import("./media-assets.js").MediaAssetPreparationOptions) => Promise<import("./media-assets.js").MediaAssetMutation>;
        cancel: (id: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-assets.js").MediaAssetOperation;
        }>;
        list: (input: {
            model: string;
            after?: string;
            limit?: number;
        }, options?: RequestOptions) => Promise<import("./media-assets.js").MediaAssetPage<import("./media-assets.js").MediaAssetOperation>>;
        retrieveByIdempotency: (idempotencyKey: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-assets.js").MediaAssetOperation;
        }>;
        retrieve: (id: string, model: string, options?: RequestOptions) => Promise<{
            data: import("./media-assets.js").MediaAssetOperation;
        }>;
    };
};

video

TypeScript

readonly video: {
    generate: (input: NiuVideoGenerationInput, options?: VideoCreateOptions) => Promise<VideoJobState>;
    models: {
        list: (options?: RequestOptions) => Promise<VideoModelList>;
    };
    estimate: (request: VideoCreateRequest, options?: RequestOptions) => Promise<VideoEstimate>;
    jobs: {
        wait: (id: string, options?: VideoWaitOptions) => Promise<VideoJobState>;
        results: {
            status: (id: string, options?: RequestOptions) => Promise<VideoResultAvailability>;
            retrieve: (id: string, kind: 'video' | 'last_frame', options?: RequestOptions) => Promise<Response>;
            refresh: (id: string, kind: 'video' | 'last_frame', options?: RequestOptions) => Promise<Response>;
            delete: (id: string, options?: RequestOptions) => Promise<{
                deleted: true;
            }>;
        };
        list: (query?: VideoJobHistoryQuery, options?: RequestOptions) => Promise<VideoJobHistory>;
        billing: (id: string, options?: RequestOptions) => Promise<VideoJobBilling>;
        timings: (id: string, options?: RequestOptions) => Promise<VideoTransportTimings>;
        observations: (id: string, query?: VideoQueryObservationQuery, options?: RequestOptions) => Promise<VideoQueryObservationPage>;
        refresh: (id: string, options?: RequestOptions) => Promise<VideoJobState>;
        create: (request: VideoCreateRequest, options?: VideoCreateOptions) => Promise<VideoJobState>;
        retrieve: (id: string, options?: RequestOptions) => Promise<VideoJobState>;
    };
};

models

TypeScript

readonly models: {
    list: (options?: RequestOptions) => Promise<ModelList>;
};

embeddings

TypeScript

readonly embeddings: {
    create: (request: EmbeddingRequest, options?: RequestOptions) => Promise<EmbeddingResponse>;
};

generateContent

TypeScript

readonly generateContent: (model: string, request: GenerateContentRequest, options?: RequestOptions) => Promise<GenerateContentResponse>;

messages

TypeScript

readonly messages: {
    create: (request: MessagesRequest, options?: RequestOptions) => Promise<MessagesResponse>;
    stream: (request: MessagesStreamRequest, options?: RequestOptions) => AsyncGenerator<unknown>;
};

responses

TypeScript

readonly responses: {
    create: (request: ResponsesRequest, options?: RequestOptions) => Promise<ResponsesResponse>;
    stream: (request: ResponsesRequest, options?: RequestOptions) => AsyncGenerator<unknown>;
};

chat

TypeScript

readonly chat: {
    completions: (request: ChatCompletionRequest, options?: RequestOptions) => Promise<ChatCompletionResponse>;
    stream: (request: ChatStreamRequest, options?: RequestOptions) => AsyncGenerator<unknown>;
};